home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / mail / pine3.96.tar.gz / pine3.96.tar / pine3.96 / pine / mailindx.c < prev    next >
C/C++ Source or Header  |  1996-07-11  |  114KB  |  4,351 lines
  1. #if !defined(lint) && !defined(DOS)
  2. static char rcsid[] = "$Id: mailindx.c,v 4.224 1996/07/11 22:47:41 mikes Exp $";
  3. #endif
  4. /*----------------------------------------------------------------------
  5.  
  6.             T H E    P I N E    M A I L   S Y S T E M
  7.  
  8.    Laurence Lundblade and Mike Seibel
  9.    Networks and Distributed Computing
  10.    Computing and Communications
  11.    University of Washington
  12.    Administration Builiding, AG-44
  13.    Seattle, Washington, 98195, USA
  14.    Internet: lgl@CAC.Washington.EDU
  15.              mikes@CAC.Washington.EDU
  16.  
  17.    Please address all bugs and comments to "pine-bugs@cac.washington.edu"
  18.  
  19.  
  20.    Pine and Pico are registered trademarks of the University of Washington.
  21.    No commercial use of these trademarks may be made without prior written
  22.    permission of the University of Washington.
  23.  
  24.    Pine, Pico, and Pilot software and its included text are Copyright
  25.    1989-1996 by the University of Washington.
  26.  
  27.    The full text of our legal notices is contained in the file called
  28.    CPYRIGHT, included with this distribution.
  29.  
  30.  
  31.    USENET News reading additions in part by L Lundblade / NorthWestNet, 1993
  32.    lgl@nwnet.net
  33.  
  34.    Pine is in part based on The Elm Mail System:
  35.     ***********************************************************************
  36.     *  The Elm Mail System  -  Revision: 2.13                             *
  37.     *                                                                     *
  38.     *             Copyright (c) 1986, 1987 Dave Taylor              *
  39.     *             Copyright (c) 1988, 1989 USENET Community Trust   *
  40.     ***********************************************************************
  41.  
  42.  
  43.   ----------------------------------------------------------------------*/
  44.  
  45. /*======================================================================
  46.     mailindx.c
  47.     Implements the mail index screen
  48.      - most code here builds the header list and displays it
  49.  
  50.  ====*/
  51.  
  52. #include "headers.h"
  53.  
  54.  
  55. static struct key index_keys[] = 
  56.        {{"?","Help",KS_SCREENHELP},    {"O","OTHER CMDS",KS_NONE},
  57.     {"M","Main Menu",KS_MAINMENU},    {"V","[ViewMsg]",KS_VIEW},
  58.     {"P","PrevMsg",KS_PREVMSG},    {"N","NextMsg",KS_NEXTMSG},
  59.     {"-","PrevPage",KS_PREVPAGE},    {"Spc","NextPage",KS_NEXTPAGE},
  60.     {"D","Delete",KS_DELETE},    {"U","Undelete",KS_UNDELETE},
  61.     {"R","Reply",KS_REPLY},        {"F","Forward",KS_FORWARD},
  62.  
  63.     {"?","Help",KS_SCREENHELP},    {"O","OTHER CMDS",KS_NONE},
  64.     {"Q","Quit",KS_EXIT},        {"C","Compose",KS_COMPOSER},
  65.     {"L","ListFldrs",KS_FLDRLIST},    {"G","GotoFldr",KS_GOTOFLDR},
  66.     {"Tab","NextNew",KS_NONE},    {"W","WhereIs",KS_WHEREIS},
  67.     {"Y","prYnt",KS_PRINT},        {"T","TakeAddr",KS_TAKEADDR},
  68.     {"S","Save",KS_SAVE},        {"E","Export",KS_EXPORT},
  69.  
  70.     {"?","Help",KS_SCREENHELP},    {"O","OTHER CMDS",KS_NONE},
  71.     {"X",NULL,KS_NONE},        {"&","unXclude",KS_NONE},
  72.     {";","Select",KS_SELECT},    {"A","Apply",KS_APPLY},
  73.     {"$","SortIndex",KS_SORT},    {"J","Jump",KS_JUMPTOMSG},
  74.     {"H","HdrMode",KS_HDRMODE},    {"B","Bounce",KS_BOUNCE},
  75.     {"*","Flag",KS_FLAG},        {"|","Pipe",KS_NONE},
  76.  
  77.     {"?","Help",KS_SCREENHELP},    {"O","OTHER CMDS",KS_NONE},
  78.     {":","SelectCur",KS_SELECTCUR},    {"Z","ZoomMode",KS_NONE},
  79.     {NULL,NULL,KS_NONE},        {NULL,NULL,KS_NONE},
  80.     {NULL,NULL,KS_NONE},        {NULL,NULL,KS_NONE},
  81.     {NULL,NULL,KS_NONE},        {NULL,NULL,KS_NONE},
  82.     {NULL,NULL,KS_NONE},        {NULL,NULL,KS_NONE}};
  83. INST_KEY_MENU(index_keymenu, index_keys);
  84. #define PREVM_KEY 4
  85. #define NEXTM_KEY 5
  86. #define EXCLUDE_KEY 26
  87. #define UNEXCLUDE_KEY 27
  88. #define SELECT_KEY 28
  89. #define APPLY_KEY 29
  90. #define VIEW_FULL_HEADERS_KEY 32
  91. #define BOUNCE_KEY 33
  92. #define FLAG_KEY 34
  93. #define VIEW_PIPE_KEY 35
  94. #define ZOOM_KEY 39
  95.  
  96. static struct key nr_anon_index_keys[] = 
  97.        {{"?","Help",KS_SCREENHELP},    {"W","WhereIs",KS_WHEREIS},
  98.     {"Q","Quit",KS_EXIT},        {"V","[ViewMsg]",KS_VIEW},
  99.     {"P","PrevMsg",KS_PREVMSG},    {"N","NextMsg",KS_NEXTMSG},
  100.     {"-","PrevPage",KS_PREVPAGE},    {"Spc","NextPage",KS_NEXTPAGE},
  101.     {"F","Fwd Email",KS_FORWARD},    {"J","Jump",KS_JUMPTOMSG},
  102.     {"$","SortIndex",KS_SORT},    {NULL,NULL,KS_NONE}};
  103. INST_KEY_MENU(nr_anon_index_keymenu, nr_anon_index_keys);
  104.  
  105. static struct key nr_index_keys[] = 
  106.        {{"?","Help",KS_SCREENHELP},    {"O","OTHER CMDS",KS_NONE},
  107.     {"Q","Quit",KS_EXIT},        {"V","[ViewMsg]",KS_VIEW},
  108.     {"P","PrevMsg",KS_PREVMSG},    {"N","NextMsg",KS_NEXTMSG},
  109.     {"-","PrevPage",KS_PREVPAGE},    {"Spc","NextPage",KS_NEXTPAGE},
  110.     {"F","Fwd Email",KS_FORWARD},    {"J","Jump",KS_JUMPTOMSG},
  111.     {"Y","prYnt",KS_PRINT},        {"S","Save",KS_SAVE},
  112.  
  113.     {"?","Help",KS_SCREENHELP},    {"O","OTHER CMDS",KS_NONE},
  114.     {"E","Export",KS_EXPORT},    {"C","Compose",KS_COMPOSER},
  115.     {"$","SortIndex",KS_SORT},    {NULL,NULL,KS_NONE},
  116.     {NULL,NULL,KS_NONE},        {"W","WhereIs",KS_WHEREIS},
  117.     {NULL,NULL,KS_NONE},        {NULL,NULL,KS_NONE},
  118.     {NULL,NULL,KS_NONE},        {NULL,NULL,KS_NONE}};
  119. INST_KEY_MENU(nr_index_keymenu, nr_index_keys);
  120.   
  121. static struct key simple_index_keys[] = 
  122.        {{"?","Help",KS_SCREENHELP},    {NULL,NULL,KS_NONE},
  123.     {"E","ExitSelect",KS_EXITMODE},    {"S","[Select]",KS_SELECT},
  124.     {"P","PrevMsg",KS_PREVMSG},    {"N","NextMsg",KS_NEXTMSG},
  125.     {"-","PrevPage",KS_PREVPAGE},    {"Spc","NextPage",KS_NEXTPAGE},
  126.     {"D","Delete",KS_DELETE},    {"U","Undelete",KS_UNDELETE},
  127.     {NULL,NULL,KS_NONE},        {NULL,NULL,KS_NONE}};
  128. INST_KEY_MENU(simple_index_keymenu, simple_index_keys);
  129.  
  130.  
  131. static OtherMenu what_keymenu = FirstMenu;
  132. jmp_buf jump_past_qsort;
  133.  
  134.  
  135. /*-----------
  136.   Saved state to redraw message index body 
  137.   ----*/
  138. struct entry_state {
  139.     unsigned hilite:1;
  140.     unsigned bolded:1;
  141.     long     id;
  142. };
  143.  
  144.  
  145. #define MAXIFLDS 20  /* max number of fields in index format */
  146. static struct index_state {
  147.     long        msg_at_top,
  148.             lines_per_page;
  149.     struct      entry_state *entry_state;
  150.     MSGNO_S    *msgmap;
  151.     MAILSTREAM *stream;
  152.     int         status_col;        /* column for select X's */
  153. } *current_index_state = NULL;
  154.  
  155. static int get_body_for_index;
  156.  
  157.  
  158. /*
  159.  * cache used by get_sub() so it doesn't have to do a fetchstructure
  160.  * and malloc/free for every qsort comparison...
  161.  */
  162. #if    defined(DOS) && !defined(_WINDOWS)
  163. #define    SUB_CACHE_LEN    128
  164. typedef struct {
  165.     short used;                /* whether entry's been used or not */
  166.     char  buf[SUB_CACHE_LEN];        /* actual subject string */
  167. } scache_ent;
  168.  
  169.  
  170. static struct scache {
  171.     short    last;            /* last one referenced */
  172.     long    size,            /* number of elements */
  173.         msgno[2];        /* which message in which entry */
  174.     scache_ent  ent[2];            /* subject and cache info for msg */
  175.     char       *cname;            /* file containing cache */
  176.     FILE       *cfile;
  177. } *scache = NULL;
  178. #else
  179. static struct scache {
  180.     long   size;
  181.     char **ent;
  182. } *scache = NULL;
  183. #endif
  184.  
  185.  
  186. /*
  187.  * Internal prototypes
  188.  */
  189. int     update_index PROTO((struct pine *, struct index_state *));
  190. int     index_scroll_up PROTO((long));
  191. int     index_scroll_down PROTO((long));
  192. int     index_scroll_to_pos PROTO((long));
  193. long     top_ent_calc PROTO((MAILSTREAM *, MSGNO_S *, long, long));
  194. char    *get_sub PROTO((long));
  195. int      compare_subjects PROTO((const QSType *, const QSType *));
  196. int      compare_subject_2 PROTO((const QSType *, const QSType *));
  197. int      compare_from PROTO((const QSType *, const QSType *));
  198. int      compare_to PROTO((const QSType *, const QSType *));
  199. int      compare_cc PROTO((const QSType *, const QSType *));
  200. int      compare_message_dates PROTO((const QSType *, const QSType *));
  201. int      compare_size PROTO((const QSType *, const QSType *));
  202. int      compare_arrival PROTO((const QSType *, const QSType *));
  203. HLINE_S *get_index_cache PROTO((long));
  204. int     set_index_addr PROTO((MAILSTREAM *, long, char *, ADDRESS *, char *,
  205.                    int, char *));
  206. int      i_cache_size PROTO((long));
  207. int      i_cache_width PROTO(());
  208. void     setup_header_widths PROTO((INDEX_COL_S *, int, long));
  209. int     parse_index_format PROTO((char *, INDEX_COL_S **));
  210. void     set_need_format_setup();
  211. void     clear_need_format_setup();
  212. int     check_need_format_setup();
  213. void     msgno_flush_selected PROTO((MSGNO_S *, long));
  214. void     second_subject_sort PROTO((long *, long, long));
  215. void     init_subject_cache PROTO((long));
  216. int     subject_cache_slot PROTO((long));
  217. char    *subject_cache_ent PROTO((long));
  218. char    *subject_cache_add PROTO((long, char *));
  219. void     clear_subject_cache PROTO(());
  220. #ifdef    DOS
  221. void     i_cache_hit PROTO((long));
  222. void     icread PROTO((void));
  223. void     icwrite PROTO((void));
  224. #ifdef    _WINDOWS
  225. int     index_scroll_callback PROTO((int,long));
  226. int     index_gettext_callback PROTO((char *, void **, long *, int *));
  227. #endif
  228. #endif
  229. long     seconds_since_epoch PROTO((long));
  230.  
  231.  
  232.  
  233.  
  234. /*----------------------------------------------------------------------
  235.  
  236.  
  237.   ----*/
  238. void
  239. do_index_border(cntxt, folder, stream, msgmap, style, which_keys, flags)
  240.      CONTEXT_S   *cntxt;
  241.      char        *folder;
  242.      MAILSTREAM  *stream;
  243.      MSGNO_S     *msgmap;
  244.      IndexType    style;
  245.      int         *which_keys, flags;
  246. {
  247.     if(flags & INDX_CLEAR)
  248.       ClearScreen();
  249.  
  250.     if(flags & INDX_HEADER)
  251.       set_titlebar((stream == ps_global->mail_stream)
  252.              ? (style == MsgIndex || style == MultiMsgIndex)
  253.                  ? "FOLDER INDEX"
  254.              : "ZOOMED FOLDER INDEX"
  255.              : (!strcmp(folder, INTERRUPTED_MAIL))
  256.              ? "COMPOSE: SELECT INTERRUPTED"
  257.              : "COMPOSE: SELECT POSTPONED",
  258.            stream, cntxt, folder, msgmap, 1, MessageNumber, 0, 0);
  259.  
  260.     if(flags & INDX_FOOTER) {
  261.     struct key_menu *km;
  262.     bitmap_t     bitmap;
  263.  
  264.     setbitmap(bitmap);
  265.     if(ps_global->anonymous)
  266.       km = &nr_anon_index_keymenu;
  267.     else if(ps_global->nr_mode)
  268.           km = &nr_index_keymenu;
  269.     else if(ps_global->mail_stream != stream)
  270.       km = &simple_index_keymenu;
  271.     else{
  272.         km = &index_keymenu;
  273.  
  274. #ifndef DOS
  275.         if(F_OFF(F_ENABLE_PIPE,ps_global))
  276. #endif
  277.           clrbitn(VIEW_PIPE_KEY, bitmap);  /* always clear for DOS */
  278.         if(F_OFF(F_ENABLE_FULL_HDR,ps_global))
  279.           clrbitn(VIEW_FULL_HEADERS_KEY, bitmap);
  280.         if(F_OFF(F_ENABLE_BOUNCE,ps_global))
  281.           clrbitn(BOUNCE_KEY, bitmap);
  282.         if(F_OFF(F_ENABLE_FLAG,ps_global))
  283.           clrbitn(FLAG_KEY, bitmap);
  284.         if(F_OFF(F_ENABLE_AGG_OPS,ps_global)){
  285.         clrbitn(SELECT_KEY, bitmap);
  286.         clrbitn(APPLY_KEY, bitmap);
  287.  
  288.         /*
  289.          * Since "Zoom" is alone on the last keymenu page
  290.          * if it's not enabled, hide that menu altogether
  291.          */
  292.         if(style != ZoomIndex){
  293.             clrbitn(ZOOM_KEY, bitmap);
  294.             km->how_many = 3;
  295.         }
  296.         else
  297.           km->how_many = 4;
  298.         }
  299.         else
  300.           km->how_many = 4;
  301.  
  302.         if(IS_NEWS(stream)){
  303.         index_keys[EXCLUDE_KEY].label = "eXclude";
  304.         KS_OSDATASET(&index_keys[EXCLUDE_KEY], KS_NONE);
  305.         }
  306.         else {
  307.         clrbitn(UNEXCLUDE_KEY, bitmap);
  308.         index_keys[EXCLUDE_KEY].label = "eXpunge";
  309.         KS_OSDATASET(&index_keys[EXCLUDE_KEY], KS_EXPUNGE);
  310.         }
  311.  
  312.         if(style == MultiMsgIndex){
  313.         clrbitn(PREVM_KEY, bitmap);
  314.         clrbitn(NEXTM_KEY, bitmap);
  315.         }
  316.     }
  317.         draw_keymenu(km, bitmap, ps_global->ttyo->screen_cols,
  318.                1-FOOTER_ROWS(ps_global), 0, what_keymenu, 0);
  319.     what_keymenu = SameTwelve;
  320.     if(which_keys)
  321.       *which_keys = km->which;  /* pass back to caller */
  322.     }
  323. }
  324.  
  325.       
  326.     
  327. /*----------------------------------------------------------------------
  328.         Main loop executing commands for the mail index screen
  329.  
  330.    Args: state -- the pine_state structure for next/prev screen pointers
  331.                   and to pass to the index manager...
  332.  ----*/
  333.  
  334. void
  335. mail_index_screen(state)
  336.      struct pine *state;
  337. {
  338.     dprint(1, (debugfile, "\n\n ---- MAIL INDEX ----\n"));
  339.     if(!state->mail_stream) {
  340.     q_status_message(SM_ORDER, 0, 3, "No folder is currently open");
  341.         state->prev_screen = mail_index_screen;
  342.     state->next_screen = main_menu_screen;
  343.     return;
  344.     }
  345.  
  346.     index_lister(state, state->context_current, state->cur_folder,
  347.          state->mail_stream, state->msgmap);
  348.     state->prev_screen = mail_index_screen;
  349. }
  350.  
  351.  
  352.  
  353. /*----------------------------------------------------------------------
  354.         Main loop executing commands for the mail index screen
  355.  
  356.    Args: state -- pine_state structure for display flags and such
  357.          msgmap -- c-client/pine message number mapping struct
  358.  ----*/
  359.  
  360. int
  361. index_lister(state, cntxt, folder, stream, msgmap)
  362.      struct pine *state;
  363.      CONTEXT_S   *cntxt;
  364.      char        *folder;
  365.      MAILSTREAM  *stream;
  366.      MSGNO_S     *msgmap;
  367. {
  368.     int         ch, orig_ch, which_keys, force, cur_row, cur_col, km_popped;
  369.     long     i, j, k, old_max_msgno;
  370.     IndexType    style, old_style = MsgIndex;
  371.     struct index_state id;
  372. #if defined(DOS) || defined(OS2)
  373.     extern void (*while_waiting)();
  374. #endif
  375.  
  376.     dprint(1, (debugfile, "\n\n ---- INDEX MANAGER ----\n"));
  377.     
  378.     ch                    = 'x';    /* For displaying msg 1st time thru */
  379.     force                 = 0;
  380.     km_popped             = 0;
  381.     state->mangled_screen = 1;
  382.     what_keymenu          = FirstMenu;
  383.     memset((void *)&id, 0, sizeof(struct index_state));
  384.     current_index_state   = &id;
  385.     id.msgmap    = msgmap;
  386.  
  387.     if((id.stream = stream) != state->mail_stream)
  388.       clear_index_cache();    /* BUG: should better tie stream to cache */
  389.  
  390.     set_need_format_setup();
  391.  
  392.     while (1) {
  393.     if(km_popped){
  394.         km_popped--;
  395.         if(km_popped == 0){
  396.         clearfooter(state);
  397.         if(!state->mangled_body
  398.            && id.entry_state
  399.            && id.lines_per_page > 1){
  400.             id.entry_state[id.lines_per_page-2].id = -1;
  401.             id.entry_state[id.lines_per_page-1].id = -1;
  402.         }
  403.         else
  404.           state->mangled_body = 1;
  405.         }
  406.     }
  407.  
  408.     old_max_msgno = mn_get_total(msgmap);
  409.  
  410.     /*------- Check for new mail -------*/
  411.         new_mail(force, NM_TIMING(ch), 1);
  412.     force = 0;            /* may not need to next time around */
  413.  
  414.     /*
  415.      * This is only actually necessary if this causes the width of the
  416.      * message number field to change.  That is, it depends on the
  417.      * format the user is using as well as on the max_msgno.  Since it
  418.      * should be rare, we'll just do it whenever it happens.
  419.      * Also have to check for a reduction in max_msgno when we expunge.
  420.      */
  421.     if(old_max_msgno < 1000L && mn_get_total(msgmap) >= 1000L
  422.        || old_max_msgno < 10000L && mn_get_total(msgmap) >= 10000L
  423.        || old_max_msgno < 100000L && mn_get_total(msgmap) >= 100000L){
  424.         clear_index_cache();
  425.         state->mangled_body = 1;
  426.         }
  427.  
  428.         if(streams_died())
  429.           state->mangled_header = 1;
  430.  
  431.         if(state->mangled_screen){
  432.             state->mangled_header = 1;
  433.             state->mangled_body   = 1;
  434.             state->mangled_footer = 1;
  435.             state->mangled_screen = 0;
  436.         }
  437.  
  438.     /*
  439.      * events may have occured that require us to shift from
  440.      * mode to another...
  441.      */
  442.     style = (any_lflagged(msgmap, MN_HIDE))
  443.           ? ZoomIndex
  444.           : (mn_total_cur(msgmap) > 1L) ? MultiMsgIndex : MsgIndex;
  445.     if(style != old_style){
  446.             state->mangled_header = 1;
  447.             state->mangled_footer = 1;
  448.         old_style = style;
  449.         id.msg_at_top = 0L;
  450.     }
  451.  
  452.         /*------------ Update the title bar -----------*/
  453.     if(state->mangled_header) {
  454.             do_index_border(cntxt, folder, stream, msgmap, style, NULL,
  455.                 INDX_HEADER);
  456.         state->mangled_header = 0;
  457.     } 
  458.     else if(mn_get_total(msgmap) > 0) {
  459.         /*
  460.          * No fetchstructure necessary before mail_elt as the elt's
  461.          * should have been loaded with the correct flags when we did
  462.          * a fetchflags as part of get_lflags the first time we painted
  463.          * the index...
  464.          */
  465.         update_titlebar_message();
  466.             update_titlebar_status();
  467.     }
  468.  
  469.     current_index_state = &id;
  470.  
  471.         /*------------ draw the index body ---------------*/
  472.     cur_row = update_index(state, &id);
  473.     if(F_OFF(F_SHOW_CURSOR, state)){
  474.         cur_row = state->ttyo->screen_rows - FOOTER_ROWS(state);
  475.         cur_col = 0;
  476.     }
  477.     else if(id.status_col >= 0)
  478.       cur_col = min(id.status_col, state->ttyo->screen_cols-1);
  479.  
  480.         ps_global->redrawer = redraw_index_body;
  481.  
  482.         /*------------ draw the footer/key menus ---------------*/
  483.     if(state->mangled_footer) {
  484.             if(!state->painted_footer_on_startup){
  485.         if(km_popped){
  486.             FOOTER_ROWS(state) = 3;
  487.             clearfooter(state);
  488.         }
  489.  
  490.         do_index_border(cntxt, folder, stream, msgmap, style,
  491.                   &which_keys, INDX_FOOTER);
  492.         if(km_popped){
  493.             FOOTER_ROWS(state) = 1;
  494.             mark_keymenu_dirty();
  495.         }
  496.         }
  497.  
  498.         state->mangled_footer = 0;
  499.     }
  500.  
  501.         state->painted_body_on_startup   = 0;
  502.         state->painted_footer_on_startup = 0;
  503.  
  504.     /*-- Display any queued message (eg, new mail, command result --*/
  505.     if(km_popped){
  506.         FOOTER_ROWS(state) = 3;
  507.         mark_status_unknown();
  508.     }
  509.  
  510.         display_message(ch);
  511.     if(km_popped){
  512.         FOOTER_ROWS(state) = 1;
  513.         mark_status_unknown();
  514.     }
  515.  
  516.     if(F_ON(F_SHOW_CURSOR, state) && cur_row < 0){
  517.         q_status_message(SM_ORDER,
  518.         (ch==NO_OP_IDLE || ch==NO_OP_COMMAND) ? 0 : 3, 5,
  519.         "No messages in folder");
  520.         cur_row = state->ttyo->screen_rows - FOOTER_ROWS(state);
  521.         display_message(ch);
  522.     }
  523.  
  524.     MoveCursor(cur_row, cur_col);
  525.  
  526.         /* Let read_command do the fflush(stdout) */
  527.  
  528.         /*---------- Read command and validate it ----------------*/
  529. #ifdef    MOUSE
  530.     if(stream == ps_global->mail_stream){    /* prime the handler */
  531.         mouse_in_content(KEY_MOUSE, -1, -1, 0x5, 0);
  532.         register_mfunc(mouse_in_content, HEADER_ROWS(ps_global), 0,
  533.                state->ttyo->screen_rows-(FOOTER_ROWS(ps_global)+1),
  534.                state->ttyo->screen_cols);
  535.                
  536.     }
  537. #endif
  538. #if defined(DOS) || defined(OS2)
  539.     /*
  540.      * AND pre-build header lines.  This works just fine under
  541.      * DOS since we wait for characters in a loop. Something will
  542.          * will have to change under UNIX if we want to do the same.
  543.      */
  544.     while_waiting = build_header_cache;
  545. #ifdef    _WINDOWS
  546.     while_waiting = NULL;
  547.     mswin_setscrollcallback (index_scroll_callback);
  548. #endif
  549. #endif
  550.     ch = read_command();
  551. #ifdef    MOUSE
  552.     if(stream == ps_global->mail_stream)
  553.       clear_mfunc(mouse_in_content);
  554. #endif
  555. #if defined(DOS) || defined(OS2)
  556.     while_waiting = NULL;
  557. #ifdef    _WINDOWS
  558.     mswin_setscrollcallback(NULL);
  559. #endif
  560. #endif
  561.  
  562.         orig_ch = ch;
  563.  
  564.     if(ch < 0x0100 && isupper((unsigned char)ch))    /* force lower case */
  565.       ch = tolower((unsigned char)ch);
  566.     else if(ch >= PF1 && ch <= PF12 && which_keys > 0 && which_keys < 4)
  567.       ch = (which_keys == 1) ? PF2OPF(ch) :    /* map f-key to menu page */
  568.         (which_keys == 2) ? PF2OOPF(ch) : PF2OOOPF(ch);
  569.  
  570.     ch = validatekeys(ch);
  571.  
  572.     if(km_popped)
  573.       switch(ch){
  574.         case NO_OP_IDLE:
  575.         case NO_OP_COMMAND: 
  576.         case PF2:
  577.         case OPF2:
  578.             case OOPF2:
  579.             case OOOPF2:
  580.         case 'o' :
  581.         case KEY_RESIZE:
  582.         case ctrl('L'):
  583.           km_popped++;
  584.           break;
  585.         
  586.         default:
  587.           clearfooter(state);
  588.           break;
  589.       }
  590.  
  591.     /*----------- Execute the command ------------------*/
  592.     switch(ch) {
  593.  
  594.             /*---------- Roll keymenu ----------*/
  595.           case PF2:
  596.           case OPF2:
  597.           case OOPF2:
  598.           case OOOPF2:
  599.       case 'o':
  600.             if(ps_global->anonymous) {
  601.           if(ch == PF2)
  602.         ch = 'w';
  603.               goto df;
  604.         }
  605.             if(ch == 'o')
  606.           warn_other_cmds();
  607.         what_keymenu = NextTwelve;
  608.         state->mangled_footer = 1;
  609.         break;
  610.  
  611.  
  612.             /*---------- Scroll back up ----------*/
  613.       case PF7:
  614.       case '-' :
  615.           case ctrl('Y'): 
  616.       case KEY_PGUP:
  617.       pageup:
  618.         j = -1L;
  619.         for(k = i = id.msg_at_top; ; i--){
  620.         if(!get_lflag(stream, msgmap, i, MN_HIDE)){
  621.             k = i;
  622.             if(++j >= id.lines_per_page){
  623.             if((id.msg_at_top = i) == 1L)
  624.               q_status_message(SM_ORDER, 0, 1, "First Index page");
  625.  
  626.             break;
  627.             }
  628.            }
  629.  
  630.         if(i <= 1L){
  631.             if(mn_get_cur(msgmap) == 1L)
  632.               q_status_message(SM_ORDER, 0, 1,
  633.               "Already at start of Index");
  634.  
  635.             break;
  636.         }
  637.         }
  638.  
  639.         if(mn_total_cur(msgmap) == 1L)
  640.           mn_set_cur(msgmap, k);
  641.  
  642.         break;
  643.  
  644.  
  645.             /*---------- Scroll forward, next page ----------*/
  646.       case PF8:
  647.       case '+':
  648.           case ctrl('V'): 
  649.       case KEY_PGDN:
  650.       case ' ':
  651.       pagedown:
  652.         j = -1L;
  653.         for(k = i = id.msg_at_top; ; i++){
  654.         if(!get_lflag(stream, msgmap, i, MN_HIDE)){
  655.             k = i;
  656.             if(++j >= id.lines_per_page){
  657.             if(i+id.lines_per_page >= mn_get_total(msgmap))
  658.               q_status_message(SM_ORDER, 0, 1, "Last Index page");
  659.  
  660.             id.msg_at_top = i;
  661.             break;
  662.             }
  663.         }
  664.  
  665.         if(i >= mn_get_total(msgmap)){
  666.             if(mn_get_cur(msgmap) == k)
  667.               q_status_message(SM_ORDER,0,1,"Already at end of Index");
  668.  
  669.             break;
  670.         }
  671.         }
  672.  
  673.         if(mn_total_cur(msgmap) == 1L)
  674.           mn_set_cur(msgmap, k);
  675.  
  676.         break;
  677.  
  678. #ifdef MOUSE        
  679.       case KEY_MOUSE:
  680.         {
  681.           static int lastWind;
  682.           MOUSEPRESS mp;
  683.           void    *text;
  684.           long    len;
  685.           int    format;
  686.           
  687.  
  688.           mouse_get_last (NULL, &mp);
  689.           mp.row -= 2;
  690.           if (mp.doubleclick && mp.button != M_BUTTON_RIGHT) {
  691.           orig_ch = ch = F_ON(F_USE_FK, ps_global) ? PF4 : 'v';
  692.           goto df;
  693.           }
  694.           else{
  695.         for(i = id.msg_at_top;
  696.             mp.row >= 0 && i <= mn_get_total(msgmap);
  697.             i++)
  698.           if(!get_lflag(stream, msgmap, i, MN_HIDE)){
  699.               mp.row--;
  700.               if(mn_total_cur(msgmap) == 1L)
  701.             mn_set_cur(msgmap, i);
  702.           }
  703. #ifdef _WINDOWS             
  704.         if (mp.button == M_BUTTON_RIGHT) {
  705.           char title[GETTEXT_TITLELEN+1];
  706.  
  707.             /* Launch text in alt window. */
  708.           if (mp.flags & M_KEY_CONTROL)
  709.             lastWind = 0;
  710.           if (index_gettext_callback (title, &text, &len, &format)) {
  711.             if (format == GETTEXT_TEXT) 
  712.               lastWind = mswin_displaytext (title, text, (size_t)len, 
  713.                           NULL, lastWind, 0);
  714.             else if (format == GETTEXT_LINES) 
  715.               lastWind = mswin_displaytext (title, NULL, 0, 
  716.                           text, lastWind, 0);
  717.           }
  718.         }
  719. #endif /* _WINDOWS */
  720.           }
  721.         }
  722.  
  723.         break;
  724. #endif    /* MOUSE */
  725.  
  726.             /*---------- Redraw/resize ----------*/
  727.           case KEY_RESIZE:
  728.         clear_index_cache();
  729.       case ctrl('L'):
  730.         mark_status_dirty();
  731.         mark_keymenu_dirty();
  732.         mark_titlebar_dirty();
  733.             state->mangled_screen = 1;        /* force repaint and... */
  734.         if(ch == ctrl('L'))
  735.           force = 1;            /* check for new mail on ^L */
  736.  
  737.             break;
  738.  
  739.  
  740.             /*---------- No op command ----------*/
  741.           case NO_OP_IDLE:
  742.       case NO_OP_COMMAND:
  743.             break;    /* no op check for new mail */
  744.  
  745.  
  746.             /*---------- Default -- all other command ----------*/
  747.           default:
  748.           df:
  749.         if((ch == '?' || ch == ctrl('G') || ch == PF1
  750.             || ch == OPF1 || ch == OOPF1 || ch == OOOPF1)
  751.         && FOOTER_ROWS(state) == 1
  752.         && km_popped == 0){
  753.         km_popped = 2;
  754.         mark_status_unknown();
  755.         mark_keymenu_dirty();
  756.         state->mangled_footer = 1;
  757.         }
  758.         else if(stream == state->mail_stream){
  759.         process_cmd(state, msgmap, ch,
  760.                 (style == MsgIndex || style == MultiMsgIndex)?1:2,
  761.                 orig_ch, &force);
  762.         if(state->next_screen != SCREEN_FUN_NULL){
  763.             ps_global->redrawer = NULL;
  764.             current_index_state = NULL;
  765.             if(id.entry_state)
  766.               fs_give((void **)&(id.entry_state));
  767.  
  768.             return(0);
  769.         }
  770.         else{
  771.             if(stream != state->mail_stream){
  772.             /*
  773.              * Must have had an failed open.  repair our
  774.              * pointers...
  775.              */
  776.             id.stream = stream = state->mail_stream;
  777.             id.msgmap = msgmap = state->msgmap;
  778.             }
  779.  
  780.             current_index_state = &id;
  781.         }
  782.  
  783.         /*
  784.          * Page framing exception handling here.  If we
  785.          * did something that should scroll-by-a-line, frame
  786.          * the page by hand here rather than leave it to the
  787.          * page-by-page framing in update_index()...
  788.          */
  789.         switch(ch){
  790.           case KEY_DOWN:
  791.           case ctrl('N'):
  792.             for(j = 0L, k = i = id.msg_at_top; ; i++){
  793.             if(!get_lflag(stream, msgmap, i, MN_HIDE)){
  794.                 k = i;
  795.                 if(j++ >= id.lines_per_page)
  796.                   break;
  797.             }
  798.  
  799.             if(i >= mn_get_total(msgmap)){
  800.                 k = 0L;        /* don't scroll */
  801.                 break;
  802.             }
  803.             }
  804.  
  805.             if(k && (mn_get_cur(msgmap) + HS_MARGIN(state)) >= k)
  806.               index_scroll_down(1L);
  807.  
  808.             break;
  809.  
  810.           case ctrl('P'):
  811.           case KEY_UP:
  812.             if(mn_get_cur(msgmap) < (id.msg_at_top + HS_MARGIN(state)))
  813.               index_scroll_up(1L);
  814.  
  815.             break;
  816.  
  817.           default:
  818.             break;
  819.         }
  820.         }
  821.         else{            /* special processing */
  822.         switch(ch){
  823.           case '?':        /* help! */
  824.           case PF1:
  825.           case ctrl('G'):
  826.             helper(h_simple_index,
  827.                (!strcmp(folder, INTERRUPTED_MAIL))
  828.                  ? "HELP FOR SELECTING INTERRUPTED MSG"
  829.                  : "HELP FOR SELECTING POSTPONED MSG",
  830.                1);
  831.             state->mangled_screen = 1;
  832.             break;
  833.  
  834.           case 'd':        /* delete */
  835.           case 'D':
  836.           case PF9:
  837.             dprint(3,(debugfile, "Special delete: msg %s\n",
  838.                   long2string(mn_get_cur(msgmap))));
  839.             {
  840.             MESSAGECACHE *mc;
  841.             long          raw;
  842.             int          del = 0;
  843.  
  844.             raw = mn_m2raw(msgmap, mn_get_cur(msgmap));
  845.             if(!mail_elt(stream, raw)->deleted){
  846.                 clear_index_cache_ent(mn_get_cur(msgmap));
  847.                 mail_setflag(stream,long2string(raw),"\\DELETED");
  848.                 update_titlebar_status();
  849.                 del++;
  850.             }
  851.  
  852.             q_status_message2(SM_ORDER, 0, 1,
  853.                       "Message %s %sdeleted",
  854.                       long2string(mn_get_cur(msgmap)),
  855.                       (del) ? "" : "already ");
  856.             }
  857.  
  858.             break;
  859.  
  860.           case 'u':        /* UNdelete */
  861.           case 'U':
  862.           case PF10:
  863.             dprint(3,(debugfile, "Special UNdelete: msg %s\n",
  864.                   long2string(mn_get_cur(msgmap))));
  865.             {
  866.             MESSAGECACHE *mc;
  867.             long          raw;
  868.             int          del = 0;
  869.  
  870.             raw = mn_m2raw(msgmap, mn_get_cur(msgmap));
  871.             if(mail_elt(stream, raw)->deleted){
  872.                 clear_index_cache_ent(mn_get_cur(msgmap));
  873.                 mail_clearflag(stream, long2string(raw),
  874.                        "\\DELETED");
  875.                 update_titlebar_status();
  876.                 del++;
  877.             }
  878.  
  879.             q_status_message2(SM_ORDER, 0, 1,
  880.                       "Message %s %sdeleted",
  881.                       long2string(mn_get_cur(msgmap)),
  882.                       (del) ? "UN" : "NOT ");
  883.             }
  884.  
  885.             break;
  886.  
  887.           case 'e':        /* exit */
  888.           case 'E':
  889.           case PF3:
  890.             ps_global->redrawer = NULL;
  891.             current_index_state = NULL;
  892.             if(id.entry_state)
  893.               fs_give((void **)&(id.entry_state));
  894.  
  895.             return(1);
  896.             break;
  897.  
  898.           case 's':        /* select */
  899.           case ctrl('M'):
  900.           case ctrl('J'):
  901.           case PF4:
  902.             ps_global->redrawer = NULL;
  903.             current_index_state = NULL;
  904.             if(id.entry_state)
  905.               fs_give((void **)&(id.entry_state));
  906.  
  907.             return(0);
  908.  
  909.           case 'p':        /* previous */
  910.           case ctrl('P'):
  911.           case KEY_UP:
  912.           case PF5:
  913.             mn_dec_cur(stream, msgmap);
  914.             break;
  915.  
  916.           case 'n':        /* next */
  917.           case ctrl('N'):
  918.           case KEY_DOWN:
  919.           case PF6:
  920.             mn_inc_cur(stream, msgmap);
  921.             break;
  922.  
  923.           default :
  924.             bogus_command(ch, NULL);
  925.             break;
  926.         }
  927.         }
  928.     }                /* The big switch */
  929.     }                    /* the BIG while loop! */
  930. }
  931.  
  932.  
  933.  
  934. /*----------------------------------------------------------------------
  935.   Manage index body painting
  936.  
  937.   Args: state - pine struct containing selected message data
  938.     index_state - struct describing what's currently displayed
  939.  
  940.   Returns: screen row number of first highlighted message
  941.  
  942.   The idea is pretty simple.  Maintain an array of index line id's that
  943.   are displayed and their hilited state.  Decide what's to be displayed
  944.   and update the screen appropriately.  All index screen painting
  945.   is done here.  Pretty simple, huh?
  946.  ----*/
  947. int
  948. update_index(state, screen)
  949.     struct pine         *state;
  950.     struct index_state  *screen;
  951. {
  952.     int  i, agg, retval = -1;
  953.     long n;
  954.  
  955.     if(!screen)
  956.       return(-1);
  957.  
  958. #ifdef _WINDOWS
  959.     mswin_beginupdate();
  960. #endif
  961.  
  962.     /*---- reset the works if necessary ----*/
  963.     if(state->mangled_body && screen->entry_state){
  964.     fs_give((void **)&(screen->entry_state));
  965.     screen->lines_per_page = 0;
  966.     ClearBody();
  967.     }
  968.  
  969.     state->mangled_body = 0;
  970.  
  971.     /*---- make sure we have a place to write state ----*/
  972.     if(screen->lines_per_page
  973.     != max(0, state->ttyo->screen_rows - FOOTER_ROWS(state)
  974.                        - HEADER_ROWS(state))){
  975.     i = screen->lines_per_page;
  976.     screen->lines_per_page
  977.         = max(0, state->ttyo->screen_rows - FOOTER_ROWS(state)
  978.                           - HEADER_ROWS(state));
  979.     if(!i){
  980.         size_t len = screen->lines_per_page * sizeof(struct entry_state);
  981.         screen->entry_state = (struct entry_state *) fs_get(len);
  982.     }
  983.     else
  984.       fs_resize((void **)&(screen->entry_state),
  985.             (size_t)screen->lines_per_page);
  986.  
  987.     for(; i < screen->lines_per_page; i++)    /* init new entries */
  988.       screen->entry_state[i].id = -1;
  989.     }
  990.  
  991.     /*---- figure out the first message on the display ----*/
  992.     if(screen->msg_at_top < 1L
  993.        || (any_lflagged(screen->msgmap, MN_HIDE) > 0L
  994.        && get_lflag(screen->stream, screen->msgmap,
  995.             screen->msg_at_top, MN_HIDE))){
  996.     screen->msg_at_top = top_ent_calc(screen->stream, screen->msgmap,
  997.                       screen->msg_at_top,
  998.                       screen->lines_per_page);
  999.     }
  1000.     else if(mn_get_cur(screen->msgmap) < screen->msg_at_top){
  1001.     long i, j, k;
  1002.  
  1003.     /* scroll back a page at a time until current is displayed */
  1004.     while(mn_get_cur(screen->msgmap) < screen->msg_at_top){
  1005.         for(i = screen->lines_per_page, j = screen->msg_at_top-1L, k = 0L;
  1006.         i > 0L && j > 0L;
  1007.         j--)
  1008.           if(!get_lflag(screen->stream, screen->msgmap, j, MN_HIDE)){
  1009.           k = j;
  1010.           i--;
  1011.           }
  1012.  
  1013.         if(i == screen->lines_per_page)
  1014.           break;                /* can't scroll back ? */
  1015.         else
  1016.           screen->msg_at_top = k;
  1017.     }
  1018.     }
  1019.     else if(mn_get_cur(screen->msgmap) >= screen->msg_at_top
  1020.                              + screen->lines_per_page){
  1021.     long i, j, k;
  1022.  
  1023.     while(1){
  1024.         for(i = screen->lines_per_page, j = k = screen->msg_at_top;
  1025.         j <= mn_get_total(screen->msgmap) && i > 0L;
  1026.         j++)
  1027.           if(!get_lflag(screen->stream, screen->msgmap, j, MN_HIDE)){
  1028.           k = j;
  1029.           i--;
  1030.           }
  1031.  
  1032.         if(mn_get_cur(screen->msgmap) <= k)
  1033.           break;
  1034.         else{
  1035.         /* set msg_at_top to next displayed message */
  1036.         for(i = k + 1L; i <= mn_get_total(screen->msgmap); i++)
  1037.           if(!get_lflag(screen->stream, screen->msgmap, i, MN_HIDE)){
  1038.               k = i;
  1039.               break;
  1040.           }
  1041.  
  1042.         screen->msg_at_top = k;
  1043.         }
  1044.     }
  1045.     }
  1046.  
  1047. #ifdef    _WINDOWS
  1048.     /* Set scroll range and position.  Note that message numbers start at 1
  1049.      * while scroll position starts at 0. */
  1050.     scroll_setrange(mn_get_total(screen->msgmap) - 1L);
  1051.     scroll_setpos(screen->msg_at_top - 1L);
  1052. #endif
  1053.  
  1054.     /*---- march thru display lines, painting whatever is needed ----*/
  1055.     for(i = 0, n = screen->msg_at_top; i < (int) screen->lines_per_page; i++){
  1056.     if(n < 1 || n > mn_get_total(screen->msgmap)){
  1057.         if(screen->entry_state[i].id){
  1058.         screen->entry_state[i].hilite = 0;
  1059.         screen->entry_state[i].bolded = 0;
  1060.         screen->entry_state[i].id     = 0L;
  1061.         ClearLine(HEADER_ROWS(state) + i);
  1062.         }
  1063.     }
  1064.     else{
  1065.         int      cur = mn_is_cur(screen->msgmap, n),
  1066.              sel = get_lflag(screen->stream,screen->msgmap,n,MN_SLCT),
  1067.              status_col;
  1068.         HLINE_S *h   = build_header_line(state,
  1069.                 screen->stream,screen->msgmap,n);
  1070.  
  1071.         status_col = screen->status_col;
  1072.  
  1073.         if(h->id != screen->entry_state[i].id
  1074.            || (cur != screen->entry_state[i].hilite)
  1075.            || (sel != screen->entry_state[i].bolded)){
  1076.         MoveCursor(HEADER_ROWS(state) + i, 0);
  1077.         if(F_ON(F_FORCE_LOW_SPEED,ps_global) || ps_global->low_speed){
  1078.             MoveCursor(HEADER_ROWS(state) + i, status_col);
  1079.             Writechar((sel) ? 'X' :
  1080.                     (cur && h->line[status_col] == ' ') ?
  1081.                     '-' : h->line[status_col], 0);
  1082.             Writechar((cur) ? '>' : h->line[status_col+1], 0);
  1083.  
  1084.             if(h->id != screen->entry_state[i].id){
  1085.             if(status_col == 0)
  1086.               PutLine0(HEADER_ROWS(state) + i, 2, &h->line[2]);
  1087.             else{ /* this will rarely be set up this way */
  1088.                 char save_char1, save_char2;
  1089.  
  1090.                 save_char1 = h->line[status_col];
  1091.                 save_char2 = h->line[status_col+1];
  1092.                 h->line[status_col] = (sel) ? 'X' :
  1093.                 (cur && save_char1 == ' ') ?
  1094.                  '-' : save_char1;
  1095.                 h->line[status_col+1] = (cur) ? '>' :
  1096.                                  save_char2;
  1097.                 PutLine0(HEADER_ROWS(state) + i, 0, &h->line[0]);
  1098.                 h->line[status_col]   = save_char1;
  1099.                 h->line[status_col+1] = save_char2;
  1100.             }
  1101.             }
  1102.         }
  1103.         else{
  1104.             char *draw = h->line;
  1105.             char  save_char;
  1106.             int   drew_X = 0;
  1107.  
  1108.             if(cur)
  1109.               StartInverse();
  1110.             
  1111.             save_char = draw[status_col];
  1112.  
  1113.             if(sel && (F_OFF(F_SELECTED_SHOWN_BOLD, state)
  1114.                    || !StartBold())){
  1115.             draw[status_col] = 'X';
  1116.             drew_X++;
  1117.             }
  1118.  
  1119.             Write_to_screen(draw);
  1120.             if(drew_X)
  1121.               draw[status_col] = save_char;
  1122.  
  1123.             if(sel && !drew_X)
  1124.               EndBold();
  1125.  
  1126.             if(cur)
  1127.               EndInverse();
  1128.         }
  1129.         }
  1130.  
  1131.         screen->entry_state[i].hilite = cur;
  1132.         screen->entry_state[i].bolded = sel;
  1133.         screen->entry_state[i].id     = h->id;
  1134.  
  1135.         if(cur && retval < 0L)
  1136.           retval = i + HEADER_ROWS(state);
  1137.     }
  1138.  
  1139.     /*--- increment n ---*/
  1140.     while(++n <= mn_get_total(screen->msgmap)
  1141.           && get_lflag(screen->stream, screen->msgmap, n, MN_HIDE))
  1142.       ;
  1143.  
  1144.     }
  1145.  
  1146. #ifdef _WINDOWS
  1147.     mswin_endupdate();
  1148. #endif
  1149.     fflush(stdout);
  1150.     return(retval);
  1151. }
  1152.  
  1153.  
  1154.  
  1155. /*----------------------------------------------------------------------
  1156.      Scroll to specified postion.
  1157.  
  1158.  
  1159.   Args: paint - TRUE when this function shoult repaint the screen.
  1160.     pos - position to scroll to.
  1161.  
  1162.   Returns: TRUE - did the scroll operation.
  1163.        FALSE - was not able to do the scroll operation.
  1164.  ----*/
  1165. int
  1166. index_scroll_to_pos (pos)
  1167. long    pos;
  1168. {
  1169.     static short bad_timing = 0;
  1170.     long    i, j, k;
  1171.     
  1172.     if(bad_timing)
  1173.       return (FALSE);
  1174.  
  1175.     /*
  1176.      * Put the requested line at the top of the screen...
  1177.      */
  1178. #if 1
  1179.     /*
  1180.      * Starting at msg 'pos' find next visable message.
  1181.      */
  1182.     for(i=pos; i <= mn_get_total(current_index_state->msgmap); i++) {
  1183.       if(!get_lflag(current_index_state->stream, 
  1184.                 current_index_state->msgmap, i, MN_HIDE)){
  1185.       current_index_state->msg_at_top = i;
  1186.       break;
  1187.       }
  1188.     }
  1189. #else
  1190.     for(i=1L, j=pos; i <= mn_get_total(current_index_state->msgmap); i++) {
  1191.       if(!get_lflag(current_index_state->stream, 
  1192.                 current_index_state->msgmap, i, MN_HIDE)){
  1193.       if((current_index_state->msg_at_top = i) > 
  1194.           mn_get_cur(current_index_state->msgmap))
  1195.         mn_set_cur(current_index_state->msgmap, i);
  1196.  
  1197.       if(--j <= 0L)
  1198.         break;
  1199.       }
  1200.     }
  1201. #endif
  1202.  
  1203.     /*
  1204.      * If single selection, move selected message to be on the sceen.
  1205.      */
  1206.     if (mn_total_cur(current_index_state->msgmap) == 1L) {
  1207.       if (current_index_state->msg_at_top > 
  1208.                   mn_get_cur (current_index_state->msgmap)) {
  1209.     /* Selection was above screen, move to top of screen. */
  1210.     mn_set_cur (current_index_state->msgmap, 
  1211.                     current_index_state->msg_at_top);
  1212.       }
  1213.       else {
  1214.     /* Scan through the screen.  If selection found, leave where is.
  1215.      * Otherwise, move to end of screen */
  1216.         for(  i = current_index_state->msg_at_top, 
  1217.             j = current_index_state->lines_per_page;
  1218.           i != mn_get_cur(current_index_state->msgmap) && 
  1219.         i <= mn_get_total(current_index_state->msgmap) && 
  1220.         j > 0L;
  1221.           i++) {
  1222.         if(!get_lflag(current_index_state->stream, 
  1223.                 current_index_state->msgmap, i, MN_HIDE)){
  1224.             j--;
  1225.             k = i;
  1226.             }
  1227.         }
  1228.     if(j <= 0L)
  1229.         /* Move to end of screen. */
  1230.         mn_set_cur(current_index_state->msgmap, k);
  1231.       }
  1232.     }
  1233.  
  1234.     bad_timing = 0;
  1235.     return (TRUE);
  1236. }
  1237.  
  1238.  
  1239.  
  1240. /*----------------------------------------------------------------------
  1241.      Adjust the index display state down a line, and repaint.
  1242.  
  1243.  
  1244.   Returns: TRUE - did the scroll operation.
  1245.        FALSE - was not able to do the scroll operation.
  1246.  ----*/
  1247. int
  1248. index_scroll_down(scroll_count)
  1249.     long scroll_count;
  1250. {
  1251.     static short bad_timing = 0;
  1252.     long i, j, k;
  1253.     long cur, total;
  1254.  
  1255.     if(bad_timing)
  1256.       return (FALSE);
  1257.  
  1258.     bad_timing = 1;
  1259.     
  1260.     
  1261.     j = -1L;
  1262.     total = mn_get_total (current_index_state->msgmap);
  1263.     for(k = i = current_index_state->msg_at_top; ; i++){
  1264.  
  1265.     /* Only examine non-hidden messages. */
  1266.         if(!get_lflag(current_index_state->stream, 
  1267.               current_index_state->msgmap, i, MN_HIDE)){
  1268.         /* Remember this message */
  1269.         k = i;
  1270.         /* Increment count of lines.  */
  1271.         if (++j >= scroll_count) {
  1272.         /* Counted enough lines, stop. */
  1273.         current_index_state->msg_at_top = k;
  1274.         break;
  1275.         }
  1276.     }
  1277.         
  1278.     /* If at last message, stop. */
  1279.     if (i >= total){
  1280.         current_index_state->msg_at_top = k;
  1281.         break;
  1282.     }
  1283.     }
  1284.  
  1285.     /*
  1286.      * If not multiple selection, see if selected message visable.  if not
  1287.      * set it to last visable message. 
  1288.      */
  1289.     if(mn_total_cur(current_index_state->msgmap) == 1L) {
  1290.     j = 0L;
  1291.     cur = mn_get_cur (current_index_state->msgmap);
  1292.     for (i = current_index_state->msg_at_top; i <= total; ++i) {
  1293.         if(!get_lflag(current_index_state->stream, 
  1294.                   current_index_state->msgmap, i, MN_HIDE)) {
  1295.             if (++j >= current_index_state->lines_per_page) {
  1296.             break;
  1297.             }
  1298.         if (i == cur) 
  1299.             break;
  1300.         }
  1301.         }
  1302.     if (i != cur) 
  1303.         mn_set_cur(current_index_state->msgmap, 
  1304.                         current_index_state->msg_at_top);
  1305.     }
  1306.  
  1307.     bad_timing = 0;
  1308.     return (TRUE);
  1309. }
  1310.  
  1311.  
  1312.  
  1313. /*----------------------------------------------------------------------
  1314.      Adjust the index display state up a line
  1315.  
  1316.   Args: paint - TRUE when this function shoult repaint the screen.
  1317.  
  1318.   Returns: TRUE - did the scroll operation.
  1319.        FALSE - was not able to do the scroll operation.
  1320.  
  1321.  ----*/
  1322. int
  1323. index_scroll_up(scroll_count)
  1324.     long scroll_count;
  1325. {
  1326.     static short bad_timing = 0;
  1327.     long i, j, k;
  1328.     long cur;
  1329.  
  1330.     if(bad_timing)
  1331.       return(FALSE);
  1332.  
  1333.     bad_timing = 1;
  1334.     
  1335.     j = -1L;
  1336.     for(k = i = current_index_state->msg_at_top; ; i--){
  1337.  
  1338.     /* Only examine non-hidden messages. */
  1339.         if(!get_lflag(current_index_state->stream, 
  1340.               current_index_state->msgmap, i, MN_HIDE)){
  1341.         /* Remember this message */
  1342.         k = i;
  1343.         /* Increment count of lines.  */
  1344.         if (++j >= scroll_count) {
  1345.         /* Counted enough lines, stop. */
  1346.         current_index_state->msg_at_top = k;
  1347.         break;
  1348.         }
  1349.     }
  1350.         
  1351.     /* If at first message, stop */
  1352.     if (i <= 1L){
  1353.         current_index_state->msg_at_top = k;
  1354.         break;
  1355.     }
  1356.     }
  1357.  
  1358.     
  1359.     /*
  1360.      * If not multiple selection, see if selected message visable.  if not
  1361.      * set it to last visable message. 
  1362.      */
  1363.     if(mn_total_cur(current_index_state->msgmap) == 1L) {
  1364.     j = 0L;
  1365.     cur = mn_get_cur (current_index_state->msgmap);
  1366.     for (    i = current_index_state->msg_at_top; 
  1367.         i <= mn_get_total(current_index_state->msgmap);
  1368.         ++i) {
  1369.         if(!get_lflag(current_index_state->stream, 
  1370.                   current_index_state->msgmap, i, MN_HIDE)) {
  1371.             if (++j >= current_index_state->lines_per_page) {
  1372.             k = i;
  1373.             break;
  1374.             }
  1375.         if (i == cur) 
  1376.             break;
  1377.         }
  1378.         }
  1379.     if (i != cur) 
  1380.         mn_set_cur(current_index_state->msgmap, k);
  1381.     }
  1382.  
  1383.  
  1384.     bad_timing = 0;
  1385.     return (TRUE);
  1386. }
  1387.  
  1388.  
  1389.  
  1390. /*----------------------------------------------------------------------
  1391.      Calculate the message number that should be at the top of the display
  1392.  
  1393.   Args: current - the current message number
  1394.         lines_per_page - the number of lines for the body of the index only
  1395.  
  1396.   Returns: -1 if the current message is -1 
  1397.            the message entry for the first message at the top of the screen.
  1398.  
  1399. When paging in the index it is always on even page boundies, and the
  1400. current message is always on the page thus the top of the page is
  1401. completely determined by the current message and the number of lines
  1402. on the page. 
  1403.  ----*/
  1404. long
  1405. top_ent_calc(stream, msgs, at_top, lines_per_page)
  1406.      MAILSTREAM *stream;
  1407.      MSGNO_S *msgs;
  1408.      long     at_top, lines_per_page;
  1409. {
  1410.     long current;
  1411.  
  1412.     current = (mn_total_cur(msgs) <= 1L) ? mn_get_cur(msgs) : at_top;
  1413.  
  1414.     if(current < 0L)
  1415.       return(-1);
  1416.  
  1417.     if(lines_per_page == 0L)
  1418.       return(current);
  1419.  
  1420.     if(any_lflagged(msgs, (MN_HIDE|MN_EXLD))){
  1421.     long n, m = 0L, t = 1L;
  1422.  
  1423.     for(n = 1L; n <= mn_get_total(msgs); n++)
  1424.       if(!get_lflag(stream, msgs, n, MN_HIDE)
  1425.          && (++m % lines_per_page) == 1L){
  1426.           if(n > current)
  1427.         break;
  1428.  
  1429.           t = n;
  1430.       }
  1431.  
  1432.     return(t);
  1433.     }
  1434.     else
  1435.       return(lines_per_page * ((current - 1L)/ lines_per_page) + 1L);
  1436. }
  1437.  
  1438.  
  1439. /*----------------------------------------------------------------------
  1440.       Initialize the index_disp_format array in ps_global from this
  1441.       format string.
  1442.  
  1443.    Args: format -- the string containing the format tokens
  1444.      answer -- put the answer here, free first if there was a previous
  1445.             value here
  1446.  ----*/
  1447. void
  1448. init_index_format(format, answer)
  1449. char         *format;
  1450. INDEX_COL_S **answer;
  1451. {
  1452.     int column = 0;
  1453.  
  1454.     set_need_format_setup();
  1455.     /* if custom format is specified, try it, else go with default */
  1456.     if(!(format && *format && parse_index_format(format, answer))){
  1457.     if(*answer)
  1458.       fs_give((void **)answer);
  1459.  
  1460.     *answer = (INDEX_COL_S *)fs_get(7*sizeof(INDEX_COL_S));
  1461.     memset((void *)(*answer), 0, 7*sizeof(INDEX_COL_S));
  1462.  
  1463.     (*answer)[column].ctype        = iStatus;
  1464.     (*answer)[column].wtype        = Fixed;
  1465.     (*answer)[column++].req_width    = 3;
  1466.  
  1467.     /*
  1468.      * WeCalculate with a non-zero req_width means that this space
  1469.      * will be reserved before calculating the percentages.  It may
  1470.      * get increased or decreased later when we see what we actually need.
  1471.      */
  1472.     (*answer)[column].ctype        = iMessNo;
  1473.     (*answer)[column++].wtype    = WeCalculate;
  1474.  
  1475.     (*answer)[column].ctype        = iDate;
  1476.     (*answer)[column].wtype        = Fixed;
  1477.     (*answer)[column++].req_width    = 6;
  1478.  
  1479.     (*answer)[column].ctype        = iFromTo;
  1480.     (*answer)[column].wtype        = Percent;
  1481.     (*answer)[column++].req_width    = 33; /* percent of rest */
  1482.  
  1483.     (*answer)[column].ctype        = iSize;
  1484.     (*answer)[column++].wtype    = WeCalculate;
  1485.  
  1486.     (*answer)[column].ctype        = iSubject;
  1487.     (*answer)[column].wtype        = Percent;
  1488.     (*answer)[column++].req_width    = 67;
  1489.  
  1490.     (*answer)[column].ctype        = iNothing;
  1491.     }
  1492.  
  1493.     /*
  1494.      * Fill in req_width's for WeCalculate items.
  1495.      */
  1496.     for(column = 0; (*answer)[column].ctype != iNothing; column++){
  1497.     if((*answer)[column].wtype == WeCalculate){
  1498.         switch((*answer)[column].ctype){
  1499.           case iStatus:
  1500.         (*answer)[column].req_width = 3;
  1501.         break;
  1502.           case iFStatus:
  1503.         (*answer)[column].req_width = 6;
  1504.         break;
  1505.           case iMessNo:
  1506.         (*answer)[column].req_width = 3;
  1507.         break;
  1508.           case iDate:
  1509.         (*answer)[column].req_width = 6;
  1510.         break;
  1511.           case iSize:
  1512.         (*answer)[column].req_width = 8;
  1513.         break;
  1514.           case iDescripSize:
  1515.         (*answer)[column].req_width = 9;
  1516.         break;
  1517.         }
  1518.     }
  1519.     }
  1520. }
  1521.  
  1522.  
  1523. struct index_parse_tokens {
  1524.     char        *name;
  1525.     IndexColType ctype;
  1526. };
  1527.  
  1528. struct index_parse_tokens itokens[] = {
  1529.     {"STATUS",      iStatus},
  1530.     {"FULLSTATUS",  iFStatus},
  1531.     {"MSGNO",       iMessNo},
  1532.     {"DATE",        iDate},
  1533.     {"FROMORTO",    iFromTo},
  1534.     {"FROM",        iFrom},
  1535.     {"TO",          iTo},
  1536.     {"SENDER",      iSender},
  1537.     {"SIZE",        iSize},
  1538.     {"DESCRIPSIZE", iDescripSize},
  1539.     {"SUBJECT",     iSubject},
  1540.     {NULL,          iNothing}
  1541. };
  1542.  
  1543. int
  1544. parse_index_format(format_str, answer)
  1545. char         *format_str;
  1546. INDEX_COL_S **answer;
  1547. {
  1548.     int i, column = 0;
  1549.     char *p, *q;
  1550.     struct index_parse_tokens *pt;
  1551.     INDEX_COL_S cdesc[MAXIFLDS]; /* temp storage for answer */
  1552.  
  1553.     get_body_for_index = 0;
  1554.     memset((void *)cdesc, 0, sizeof(cdesc));
  1555.  
  1556.     p = format_str;
  1557.     while(p && *p && column < MAXIFLDS-1){
  1558.     /* skip leading white space for next word */
  1559.     while(p && *p && isspace((unsigned char)*p))
  1560.       p++;
  1561.     
  1562.     /* look for the token this word matches */
  1563.     for(pt = itokens; pt->name; pt++)
  1564.         if(!struncmp(pt->name, p, strlen(pt->name)))
  1565.           break;
  1566.     
  1567.     /* ignore unrecognized word */
  1568.     if(!pt->name){
  1569.         for(q = p; *p && !isspace((unsigned char)*p); p++)
  1570.           ;
  1571.  
  1572.         if(*p)
  1573.           *p++ = '\0';
  1574.  
  1575.         dprint(1, (debugfile,
  1576.                "parse_index_format: unrecognized token: %s\n", q));
  1577.         q_status_message1(SM_ORDER | SM_DING, 0, 3,
  1578.                   "Unrecognized string in index-format: %s", q);
  1579.         continue;
  1580.     }
  1581.  
  1582.     cdesc[column].ctype = pt->ctype;
  1583.     if(pt->ctype == iDescripSize)
  1584.       get_body_for_index = 1;
  1585.  
  1586.     /* skip over name and look for parens */
  1587.     p += strlen(pt->name);
  1588.     if(*p == '('){
  1589.         p++;
  1590.         q = p;
  1591.         while(p && *p && isdigit((unsigned char)*p))
  1592.           p++;
  1593.         
  1594.         if(p && *p && *p == ')' && p > q){
  1595.         cdesc[column].wtype = Fixed;
  1596.         cdesc[column].req_width = atoi(q);
  1597.         }
  1598.         else if(p && *p && *p == '%' && p > q){
  1599.         cdesc[column].wtype = Percent;
  1600.         cdesc[column].req_width = atoi(q);
  1601.         }
  1602.         else{
  1603.         cdesc[column].wtype = WeCalculate;
  1604.         cdesc[column].req_width = 0;
  1605.         }
  1606.     }
  1607.     else{
  1608.         cdesc[column].wtype     = WeCalculate;
  1609.         cdesc[column].req_width = 0;
  1610.     }
  1611.  
  1612.     column++;
  1613.     /* skip text at end of word */
  1614.     while(p && *p && !isspace((unsigned char)*p))
  1615.       p++;
  1616.     }
  1617.  
  1618.     /* if, after all that, we didn't find anything recoznizable, bitch */
  1619.     if(!column){
  1620.     dprint(1, (debugfile, "Completely unrecognizable index-format\n"));
  1621.     q_status_message(SM_ORDER | SM_DING, 0, 3,
  1622.          "Configured \"index-format\" unrecognizable. Using default.");
  1623.     return(0);
  1624.     }
  1625.  
  1626.     /* Finish with Nothing column */
  1627.     cdesc[column].ctype = iNothing;
  1628.  
  1629.     /* free up old answer */
  1630.     if(*answer)
  1631.       fs_give((void **)answer);
  1632.  
  1633.     /* allocate space for new answer */
  1634.     *answer = (INDEX_COL_S *)fs_get((column+1)*sizeof(INDEX_COL_S));
  1635.     memset((void *)(*answer), 0, (column+1)*sizeof(INDEX_COL_S));
  1636.     /* copy answer to real place */
  1637.     for(i = 0; i <= column; i++)
  1638.       (*answer)[i] = cdesc[i];
  1639.  
  1640.     return(1);
  1641. }
  1642.  
  1643.  
  1644. /*----------------------------------------------------------------------
  1645.     This redraws the body of the index screen, taking into
  1646. account any change in the size of the screen. All the state needed to
  1647. repaint is in the static variables so this can be called from
  1648. anywhere.
  1649.  ----*/
  1650. void
  1651. redraw_index_body()
  1652. {
  1653.     int agg;
  1654.  
  1655.     if(agg = (mn_total_cur(current_index_state->msgmap) > 1L))
  1656.       restore_selected(current_index_state->msgmap);
  1657.  
  1658.     ps_global->mangled_body = 1;
  1659.  
  1660.     (void) update_index(ps_global, current_index_state);
  1661.     if(agg)
  1662.       pseudo_selected(current_index_state->msgmap);
  1663. }
  1664.  
  1665.  
  1666.  
  1667. /*----------------------------------------------------------------------
  1668.       Setup the widths of the various columns in the index display
  1669.  
  1670.    Args: news      -- mail stream is news
  1671.      max_msgno -- max message number in mail stream
  1672.  ----*/
  1673. void
  1674. setup_header_widths(cdesc, news, max_msgno)
  1675.     INDEX_COL_S *cdesc;
  1676.     int          news;
  1677.     long         max_msgno;
  1678. {
  1679.     int       i, j, columns, some_to_calculate;
  1680.     int          space_left, screen_width, width, fix, col, scol, altcol;
  1681.     int          keep_going, tot_pct, was_sl;
  1682.     WidthType wtype;
  1683.  
  1684.  
  1685.     dprint(8, (debugfile, "=== setup_header_widths(%d,%ld) ===\n",
  1686.     news, max_msgno));
  1687.  
  1688.     clear_need_format_setup();
  1689.     screen_width = ps_global->ttyo->screen_cols;
  1690.     columns = 0;
  1691.     some_to_calculate = 0;
  1692.     space_left = screen_width;
  1693.  
  1694.     /*
  1695.      * Calculate how many fields there are so we know how many spaces
  1696.      * between columns to reserve.  Fill in Fixed widths now.  Reserve
  1697.      * special case WeCalculate with non-zero req_widths before doing
  1698.      * Percent cases below.
  1699.      */
  1700.     for(i = 0; cdesc[i].ctype != iNothing; i++){
  1701.  
  1702.     /* These aren't included in nr mode */
  1703.     if(ps_global->nr_mode && (cdesc[i].ctype == iFromTo ||
  1704.                   cdesc[i].ctype == iFrom ||
  1705.                   cdesc[i].ctype == iSender ||
  1706.                   cdesc[i].ctype == iTo)){
  1707.         cdesc[i].req_width = 0;
  1708.         cdesc[i].width = 0;
  1709.         cdesc[i].wtype = Fixed;
  1710.     }
  1711.     else if(cdesc[i].wtype == Fixed){
  1712.       cdesc[i].width = cdesc[i].req_width;
  1713.       if(cdesc[i].width > 0)
  1714.         columns++;
  1715.     }
  1716.     else if(cdesc[i].wtype == Percent){
  1717.         cdesc[i].width = 0; /* calculated later */
  1718.         columns++;
  1719.     }
  1720.     else{ /* WeCalculate */
  1721.         cdesc[i].width = cdesc[i].req_width; /* reserve this for now */
  1722.         some_to_calculate++;
  1723.         columns++;
  1724.     }
  1725.  
  1726.     space_left -= cdesc[i].width;
  1727.     }
  1728.  
  1729.     space_left -= (columns - 1); /* space between columns */
  1730.  
  1731.     for(i = 0; cdesc[i].ctype != iNothing; i++){
  1732.     wtype = cdesc[i].wtype;
  1733.     if(wtype != WeCalculate && wtype != Percent && cdesc[i].width == 0)
  1734.       continue;
  1735.  
  1736.     switch(cdesc[i].ctype){
  1737.       case iStatus:
  1738.         cdesc[i].actual_length = 3;
  1739.         cdesc[i].adjustment = Left;
  1740.         break;
  1741.  
  1742.       case iFStatus:
  1743.         cdesc[i].actual_length = 6;
  1744.         cdesc[i].adjustment = Left;
  1745.         break;
  1746.  
  1747.       case iDate:
  1748.         cdesc[i].actual_length = 6;
  1749.         cdesc[i].adjustment = Left;
  1750.         break;
  1751.  
  1752.       case iFromTo:
  1753.       case iFrom:
  1754.       case iSender:
  1755.       case iTo:
  1756.       case iSubject:
  1757.         cdesc[i].adjustment = Left;
  1758.         break;
  1759.  
  1760.       case iMessNo:
  1761.         if(max_msgno < 1000)
  1762.           cdesc[i].actual_length = 3;
  1763.         else if(max_msgno < 10000)
  1764.           cdesc[i].actual_length = 4;
  1765.         else if(max_msgno < 100000)
  1766.           cdesc[i].actual_length = 5;
  1767.         else
  1768.           cdesc[i].actual_length = 6;
  1769.  
  1770.         cdesc[i].adjustment = Right;
  1771.         break;
  1772.  
  1773.       case iSize:
  1774.         if(news)
  1775.           cdesc[i].actual_length = 0;
  1776.         else
  1777.           cdesc[i].actual_length = 8;
  1778.  
  1779.         cdesc[i].adjustment = Right;
  1780.         break;
  1781.  
  1782.       case iDescripSize:
  1783.         if(news)
  1784.           cdesc[i].actual_length = 0;
  1785.         else
  1786.           cdesc[i].actual_length = 9;
  1787.  
  1788.         cdesc[i].adjustment = Right;
  1789.         break;
  1790.     }
  1791.     }
  1792.  
  1793.     /* if have reserved unneeded space for size, give it back */
  1794.     for(i = 0; cdesc[i].ctype != iNothing; i++){
  1795.       if(cdesc[i].ctype == iSize || cdesc[i].ctype == iDescripSize){
  1796.     if(cdesc[i].actual_length == 0){
  1797.       if((fix=cdesc[i].width) > 0){ /* had this reserved */
  1798.         cdesc[i].width = 0;
  1799.         space_left += fix;
  1800.       }
  1801.  
  1802.       space_left++;  /* +1 for space between columns */
  1803.     }
  1804.       }
  1805.     }
  1806.  
  1807.     /*
  1808.      * Calculate the field widths that are basically fixed in width.
  1809.      * Do them in this order in case we don't have enough space to go around.
  1810.      */
  1811.     for(j = 0; j < 6 && space_left > 0 && some_to_calculate; j++){
  1812.       IndexColType targetctype;
  1813.  
  1814.       switch(j){
  1815.     case 0:
  1816.       targetctype = iMessNo;
  1817.       break;
  1818.  
  1819.     case 1:
  1820.       targetctype = iStatus;
  1821.       break;
  1822.  
  1823.     case 2:
  1824.       targetctype = iFStatus;
  1825.       break;
  1826.  
  1827.     case 3:
  1828.       targetctype = iDate;
  1829.       break;
  1830.  
  1831.     case 4:
  1832.       targetctype = iSize;
  1833.       break;
  1834.  
  1835.     case 5:
  1836.       targetctype = iDescripSize;
  1837.       break;
  1838.       }
  1839.  
  1840.       for(i = 0;
  1841.       cdesc[i].ctype != iNothing && space_left >0 && some_to_calculate;
  1842.       i++){
  1843.     if(cdesc[i].ctype == targetctype && cdesc[i].wtype == WeCalculate){
  1844.       some_to_calculate--;
  1845.       fix = min(cdesc[i].actual_length - cdesc[i].width, space_left);
  1846.       cdesc[i].width += fix;
  1847.       space_left -= fix;
  1848.     }
  1849.       }
  1850.     }
  1851.  
  1852.     /*
  1853.      * Fill in widths for Percent cases.  If there are no more to calculate,
  1854.      * use the percentages as relative numbers and use the rest of the space,
  1855.      * else treat them as absolute percentages of the original avail screen.
  1856.      */
  1857.     if(space_left > 0){
  1858.       if(some_to_calculate){
  1859.         for(i = 0; cdesc[i].ctype != iNothing && space_left > 0; i++){
  1860.         if(cdesc[i].wtype == Percent){
  1861.         /* The 2, 200, and +100 are because we're rounding */
  1862.         fix = ((2*cdesc[i].req_width *
  1863.             (screen_width-(columns-1)))+100) / 200;
  1864.             fix = min(fix, space_left);
  1865.             cdesc[i].width += fix;
  1866.             space_left -= fix;
  1867.         }
  1868.     }
  1869.       }
  1870.       else{
  1871.     tot_pct = 0;
  1872.     was_sl = space_left;
  1873.     /* add up total percentages requested */
  1874.         for(i = 0; cdesc[i].ctype != iNothing; i++)
  1875.         if(cdesc[i].wtype == Percent)
  1876.           tot_pct += cdesc[i].req_width;
  1877.  
  1878.     /* give relative weight to requests */
  1879.         for(i = 0;
  1880.         cdesc[i].ctype != iNothing && space_left > 0 && tot_pct > 0;
  1881.         i++){
  1882.         if(cdesc[i].wtype == Percent){
  1883.         fix = ((2*cdesc[i].req_width*was_sl)+tot_pct) / (2*tot_pct);
  1884.             fix = min(fix, space_left);
  1885.             cdesc[i].width += fix;
  1886.             space_left -= fix;
  1887.         }
  1888.     }
  1889.       }
  1890.     }
  1891.  
  1892.     /* split up rest, give twice as much to Subject */
  1893.     keep_going = 1;
  1894.     while(space_left > 0 && keep_going){
  1895.       keep_going = 0;
  1896.       for(i = 0; cdesc[i].ctype != iNothing && space_left > 0; i++){
  1897.     if(cdesc[i].wtype == WeCalculate &&
  1898.       (cdesc[i].ctype == iFromTo ||
  1899.        cdesc[i].ctype == iFrom ||
  1900.        cdesc[i].ctype == iSender ||
  1901.        cdesc[i].ctype == iTo ||
  1902.        cdesc[i].ctype == iSubject)){
  1903.       keep_going++;
  1904.       cdesc[i].width++;
  1905.       space_left--;
  1906.       if(space_left > 0 && cdesc[i].ctype == iSubject){
  1907.           cdesc[i].width++;
  1908.           space_left--;
  1909.       }
  1910.     }
  1911.       }
  1912.     }
  1913.  
  1914.     /* if still more, pad out percent's */
  1915.     keep_going = 1;
  1916.     while(space_left > 0 && keep_going){
  1917.       keep_going = 0;
  1918.       for(i = 0; cdesc[i].ctype != iNothing && space_left > 0; i++){
  1919.     if(cdesc[i].wtype == Percent &&
  1920.       (cdesc[i].ctype == iFromTo ||
  1921.        cdesc[i].ctype == iFrom ||
  1922.        cdesc[i].ctype == iSender ||
  1923.        cdesc[i].ctype == iTo ||
  1924.        cdesc[i].ctype == iSubject)){
  1925.       keep_going++;
  1926.       cdesc[i].width++;
  1927.       space_left--;
  1928.     }
  1929.       }
  1930.     }
  1931.  
  1932.     col = 0;
  1933.     scol = -1;
  1934.     altcol = -1;
  1935.     /* figure out what column is start of status field */
  1936.     for(i = 0; cdesc[i].ctype != iNothing; i++){
  1937.     width = cdesc[i].width;
  1938.     if(width == 0)
  1939.       continue;
  1940.  
  1941.     /* space between columns */
  1942.     if(col > 0)
  1943.       col++;
  1944.  
  1945.     if(cdesc[i].ctype == iStatus){
  1946.         scol = col;
  1947.         break;
  1948.     }
  1949.  
  1950.     if(cdesc[i].ctype == iFStatus){
  1951.         scol = col;
  1952.         break;
  1953.     }
  1954.  
  1955.     if(cdesc[i].ctype == iMessNo)
  1956.       altcol = col;
  1957.  
  1958.     col += width;
  1959.     }
  1960.  
  1961.     if(scol == -1){
  1962.     if(altcol == -1)
  1963.       scol = 0;
  1964.     else
  1965.       scol = altcol;
  1966.     }
  1967.  
  1968.     if(current_index_state)
  1969.       current_index_state->status_col = scol;
  1970. }
  1971.  
  1972.  
  1973.  
  1974. /*----------------------------------------------------------------------
  1975.       Create a string summarizing the message header for index on screen
  1976.  
  1977.    Args: stream -- mail stream to fetch envelope info from
  1978.      msgmap -- message number to pine sort mapping
  1979.      msgno  -- Message number to create line for
  1980.  
  1981.   Result: returns a malloced string
  1982.           saves string in a cache for next call for same header
  1983.  ----*/
  1984. HLINE_S *
  1985. build_header_line(state, stream, msgmap, msgno)
  1986.     struct pine *state;
  1987.     MAILSTREAM  *stream;
  1988.     MSGNO_S     *msgmap;
  1989.     long         msgno;
  1990. {
  1991.     ENVELOPE     *envelope;
  1992.     MESSAGECACHE *cache;
  1993.     ADDRESS      *addr;
  1994.     char          str_buf[MAXIFLDS][MAX_SCREEN_COLS+1], to_us, *field;
  1995.     char         *s_tmp, *buffer, *p, *str;
  1996.     HLINE_S      *hline;
  1997.     struct date   d;
  1998.     INDEX_COL_S  *cdesc;
  1999.     int           i, width, which_array, no_data = 0;
  2000.     BODY *body = NULL, **bodyp;
  2001.  
  2002.  
  2003.     dprint(8, (debugfile, "=== build_header_line(%ld) ===\n", msgno));
  2004.  
  2005.     if(check_need_format_setup())
  2006.       setup_header_widths(state->index_disp_format, IS_NEWS(stream),
  2007.               mn_get_total(msgmap));
  2008.  
  2009.     /* cache hit */
  2010.     if(*(buffer = (hline = get_index_cache(msgno))->line) != '\0') {
  2011.         dprint(9, (debugfile, "Hit: Returning %p -> <%s (%d), %ld>\n",
  2012.            hline, buffer, strlen(buffer), hline->id));
  2013.     return(hline);
  2014.     }
  2015.  
  2016.     bodyp = (get_body_for_index && !IS_NEWS(stream)) ? &body : NULL;
  2017.  
  2018.     envelope = mail_fetchstructure(stream, mn_m2raw(msgmap, msgno), bodyp);
  2019.     cache    = mail_elt(stream, mn_m2raw(msgmap, msgno));
  2020.  
  2021.     if(!envelope || !cache)
  2022.       no_data = 2;
  2023.     /*
  2024.      * Check that the envelope returned has something to display.
  2025.      * If empty, indicate that no message info found.
  2026.      */
  2027.     else if(!envelope->remail && !envelope->return_path && !envelope->date &&
  2028.        !envelope->from && !envelope->sender && !envelope->reply_to &&
  2029.        !envelope->subject && !envelope->to && !envelope->cc &&
  2030.        !envelope->bcc && !envelope->in_reply_to && !envelope->message_id &&
  2031.        !envelope->newsgroups)
  2032.       no_data = 1;
  2033.  
  2034.     cdesc = state->index_disp_format;
  2035.     which_array = 0;
  2036.  
  2037.     /* calculate contents of the required fields */
  2038.     for(i = 0; cdesc[i].ctype != iNothing; i++){
  2039.     width  = cdesc[i].width;
  2040.     if(width == 0)
  2041.       continue;
  2042.  
  2043.     str             = str_buf[which_array++];
  2044.     str[0]          = '\0';
  2045.     cdesc[i].string = str;
  2046.     if(no_data){
  2047.         if(cdesc[i].ctype == iMessNo)
  2048.           sprintf(str, "%ld", msgno);
  2049.         else if(no_data < 2 && cdesc[i].ctype == iSubject)
  2050.           sprintf(str, "%-*.*s", width, width,
  2051.               "[ No Message Text Available ]");
  2052.     }
  2053.     else{
  2054.  
  2055.         switch(cdesc[i].ctype){
  2056.           case iStatus:
  2057.         to_us = (cache->flagged) ? '*' : ' ';
  2058.         for(addr = envelope->to; addr && to_us == ' '; addr=addr->next)
  2059.           if(address_is_us(addr, ps_global))
  2060.             to_us = '+';
  2061.  
  2062. #ifdef    LATER
  2063.     if(to_us == ' '){                /* look for reset-to */
  2064.     char    *fields[2], *resent, *p;
  2065.     ADDRESS *resent_addr = NULL;
  2066.  
  2067.     fields[0] = "Resent-To";
  2068.     fields[1] = NULL;
  2069.     resent = xmail_fetchheader_lines(stream,mn_m2raw(msgmap,msgno),fields);
  2070.     if(resent){
  2071.         if(p = strchr(resent, ':')){
  2072.         for(++p; *p && isspace((unsigned char)*p); p++)
  2073.           ;
  2074.  
  2075.         removing_trailing_white_space(p);
  2076.         rfc822_parse_adrlist(&resent_addr, p, ps_global->maildomain);
  2077.         for(addr = resent_addr; addr && to_us == ' '; addr=addr->next)
  2078.           if(address_is_us(addr, ps_global))
  2079.             to_us = '+';
  2080.  
  2081.         mail_free_address(&resent_addr);
  2082.         }
  2083.  
  2084.         fs_give((void **)&resent);
  2085.     }
  2086.     }
  2087. #endif
  2088.  
  2089.         sprintf(str, "%c %s", to_us, status_string(stream, cache));
  2090.         break;
  2091.  
  2092.           case iFStatus:
  2093.            {char new, answered, deleted, flagged;
  2094.  
  2095.         to_us = ' ';
  2096.         for(addr = envelope->to; addr && to_us == ' '; addr=addr->next)
  2097.           if(address_is_us(addr, ps_global))
  2098.             to_us = '+';
  2099.         new = answered = deleted = flagged = ' ';
  2100.         if(cache && !ps_global->nr_mode){
  2101.             if(!cache->seen &&
  2102.               (!stream
  2103.                || !IS_NEWS(stream)
  2104.                || (cache->recent&&F_ON(F_FAKE_NEW_IN_NEWS,ps_global))))
  2105.               new = 'N';
  2106.  
  2107.             if(cache->answered)
  2108.               answered = 'A';
  2109.  
  2110.             if(cache->deleted)
  2111.               deleted = 'D';
  2112.  
  2113.             if(cache->flagged)
  2114.               flagged = '*';
  2115.         }
  2116.  
  2117.         sprintf(str, "%c %c%c%c%c", to_us,
  2118.             flagged, new, answered, deleted);
  2119.            }
  2120.         break;
  2121.  
  2122.           case iMessNo:
  2123.         sprintf(str, "%ld", msgno);
  2124.         break;
  2125.  
  2126.           case iDate:
  2127.         parse_date(envelope->date, &d);
  2128.         sprintf(str, "%s %2d", month_abbrev(d.month), d.day);
  2129.         break;
  2130.  
  2131.           case iFromTo:
  2132.         addr = envelope->to ? envelope->to
  2133.                      : envelope->cc ? envelope->cc : NULL;
  2134.         field = envelope->to ? "To" : envelope->cc ? "Cc" : NULL;
  2135.         if(addr && (!envelope->from ||
  2136.                address_is_us(envelope->from, ps_global))){
  2137.  
  2138.             if(width > 4)
  2139.               set_index_addr(stream, mn_m2raw(msgmap, msgno),
  2140.                      field, addr, "To: ", width, str);
  2141.             else{
  2142.             strcpy(str, "To: ");
  2143.             str[width] = '\0';
  2144.             }
  2145.             
  2146.             break;
  2147.         }
  2148.  
  2149.         /*
  2150.          * Note: Newsgroups won't work over imap so we won't get
  2151.          * it in that case, and we'll use from.  We don't want to
  2152.          * waste an rtt getting it.
  2153.          */
  2154.         if(!addr && envelope->newsgroups
  2155.                && (!envelope->from
  2156.                || address_is_us(envelope->from, ps_global))){
  2157.             if(width > 4)
  2158.               sprintf(str, "To: %-*.*s", width-4, width-4,
  2159.                   envelope->newsgroups);
  2160.             else{
  2161.             strcpy(str, "To: ");
  2162.             str[width] = '\0';
  2163.             }
  2164.  
  2165.             break;
  2166.         }
  2167.         /* ELSE fall thru and act like a "From" */
  2168.  
  2169.           case iFrom:
  2170.         set_index_addr(stream, mn_m2raw(msgmap, msgno),
  2171.                    "From", envelope->from, NULL, width, str);
  2172.         break;
  2173.  
  2174.           case iTo:
  2175.         addr = envelope->to ? envelope->to
  2176.                      : envelope->cc ? envelope->cc : NULL;
  2177.         field = envelope->to ? "To" : envelope->cc ? "Cc" : NULL;
  2178.         if(!set_index_addr(stream, mn_m2raw(msgmap, msgno),
  2179.                    field, addr, NULL, width, str)
  2180.            && envelope->newsgroups)
  2181.           sprintf(str, "%-*.*s", width, width, envelope->newsgroups);
  2182.  
  2183.         break;
  2184.  
  2185.           case iSender:
  2186.         set_index_addr(stream, mn_m2raw(msgmap, msgno),
  2187.                    "Sender", envelope->sender, NULL, width, str);
  2188.         break;
  2189.  
  2190.           case iSize:
  2191.         if(!IS_NEWS(stream)){
  2192.             if(cache->rfc822_size < 100000){
  2193.             s_tmp = comatose(cache->rfc822_size);
  2194.             sprintf(str, "(%s)", s_tmp);
  2195.             }
  2196.             else if(cache->rfc822_size < 10000000){
  2197.             s_tmp = comatose(cache->rfc822_size/1000);
  2198.             sprintf(str, "(%sK)", s_tmp);
  2199.             }
  2200.             else
  2201.               strcpy(str, "(BIG!)");
  2202.         }
  2203.  
  2204.         break;
  2205.  
  2206.           case iDescripSize:
  2207.         if(!IS_NEWS(stream) && body){
  2208.           switch(body->type){
  2209.             case TYPETEXT:
  2210.               if(cache->rfc822_size < 6000)
  2211.             strcpy(str, "(short  )");
  2212.               else if(cache->rfc822_size < 25000)
  2213.             strcpy(str, "(medium )");
  2214.               else if(cache->rfc822_size < 100000)
  2215.             strcpy(str, "(long   )");
  2216.               else
  2217.             strcpy(str, "(huge   )");
  2218.  
  2219.               break;
  2220.  
  2221.             case TYPEMULTIPART:
  2222.               if(strucmp(body->subtype, "MIXED") == 0){
  2223.             switch(body->contents.part->body.type){
  2224.               case TYPETEXT:
  2225.                 if(body->contents.part->body.size.bytes < 6000)
  2226.                   strcpy(str, "(short+ )");
  2227.                 else if(body->contents.part->body.size.bytes < 25000)
  2228.                   strcpy(str, "(medium+)");
  2229.                 else if(body->contents.part->body.size.bytes < 100000)
  2230.                   strcpy(str, "(long+  )");
  2231.                 else
  2232.                   strcpy(str, "(huge+  )");
  2233.                 break;
  2234.  
  2235.               default:
  2236.                 strcpy(str, "(multi  )");
  2237.                 break;
  2238.             }
  2239.               }
  2240.               else if(strucmp(body->subtype, "DIGEST") == 0)
  2241.             strcpy(str, "(digest )");
  2242.               else if(strucmp(body->subtype, "ALTERNATIVE") == 0)
  2243.             strcpy(str, "(mul/alt)");
  2244.               else if(strucmp(body->subtype, "PARALLEL") == 0)
  2245.             strcpy(str, "(mul/par)");
  2246.               else
  2247.                 strcpy(str, "(multi  )");
  2248.  
  2249.               break;
  2250.  
  2251.             case TYPEMESSAGE:
  2252.               strcpy(str, "(message)");
  2253.               break;
  2254.  
  2255.             case TYPEAPPLICATION:
  2256.               strcpy(str, "(applica)");
  2257.               break;
  2258.  
  2259.             case TYPEAUDIO:
  2260.               strcpy(str, "(audio  )");
  2261.               break;
  2262.  
  2263.             case TYPEIMAGE:
  2264.               strcpy(str, "(image  )");
  2265.               break;
  2266.  
  2267.             case TYPEVIDEO:
  2268.               strcpy(str, "(video  )");
  2269.               break;
  2270.  
  2271.             default:
  2272.               strcpy(str, "(other  )");
  2273.               break;
  2274.           }
  2275.         }
  2276.         break;
  2277.  
  2278.           case iSubject:
  2279.         p = str;
  2280.         if(ps_global->nr_mode){
  2281.             str[0] = ' ';
  2282.             str[1] = '\0';
  2283.             p++;
  2284.             width--;
  2285.         }
  2286.  
  2287.         if(envelope->subject)
  2288.           istrncpy(p,
  2289.                (char*)rfc1522_decode((unsigned char *)tmp_20k_buf,
  2290.                          envelope->subject, NULL),
  2291.                width);
  2292.  
  2293.         break;
  2294.         }
  2295.     }
  2296.     }
  2297.  
  2298.     *buffer = '\0';
  2299.     p = buffer;
  2300.     /*--- Put them all together ---*/
  2301.     for(i = 0; cdesc[i].ctype != iNothing; i++){
  2302.     width = cdesc[i].width;
  2303.     if(width == 0)
  2304.       continue;
  2305.  
  2306.     /* space between columns */
  2307.     if(p > buffer){
  2308.         *p++ = ' ';
  2309.         *p = '\0';
  2310.     }
  2311.  
  2312.     if(cdesc[i].adjustment == Left)
  2313.       sprintf(p, "%-*.*s", width, width, cdesc[i].string);
  2314.     else
  2315.       sprintf(p, "%*.*s", width, width, cdesc[i].string);
  2316.     
  2317.     p += width;
  2318.     }
  2319.  
  2320.     /* Truncate it to be sure not too wide */
  2321.     buffer[min(ps_global->ttyo->screen_cols, i_cache_width())] = '\0';
  2322.     hline->id = line_hash(buffer);
  2323.     dprint(9, (debugfile, "Returning %p -> <%s (%d), %ld>\n",
  2324.            hline, buffer, strlen(buffer), hline->id));
  2325.     return(hline);
  2326. }
  2327.  
  2328.  
  2329. int
  2330. set_index_addr(stream, msgno, field, addr, prefix, width, s)
  2331.     MAILSTREAM *stream;
  2332.     long    msgno;
  2333.     char       *field;
  2334.     ADDRESS    *addr;
  2335.     char       *prefix;
  2336.     int        width;
  2337.     char       *s;
  2338. {
  2339.     ADDRESS *atmp;
  2340.  
  2341.     for(atmp = addr; stream && atmp; atmp = atmp->next)
  2342.       if(atmp->host && atmp->host[0] == '.'){
  2343.       char *p, *h, *fields[2];
  2344.  
  2345.       fields[0] = field;
  2346.       fields[1] = NULL;
  2347.       if(h = xmail_fetchheader_lines(stream, msgno, fields)){
  2348.           /* skip "field:" */
  2349.           for(p = h + strlen(field) + 1;
  2350.           *p && isspace((unsigned char)*p); p++)
  2351.         ;
  2352.  
  2353.           while(width--)
  2354.         if(*p == '\015' || *p == '\012')
  2355.           p++;                /* skip CR LF */
  2356.         else if(!*p)
  2357.           *s++ = ' ';
  2358.         else
  2359.           *s++ = *p++;
  2360.  
  2361.           *s = '\0';            /* tie off return string */
  2362.           fs_give((void **) &h);
  2363.           return(TRUE);
  2364.       }
  2365.       /* else fall thru and display what c-client gave us */
  2366.       }
  2367.  
  2368.     if(addr && !addr->next        /* only one address */
  2369.        && addr->host            /* not group syntax */
  2370.        && addr->personal){        /* there is a personal name */
  2371.     char *dummy = NULL;
  2372.     int   l;
  2373.  
  2374.     if(l = prefix ? strlen(prefix) : 0)
  2375.       strcpy(s, prefix);
  2376.  
  2377.     istrncpy(s + l,
  2378.          (char *) rfc1522_decode((unsigned char *)tmp_20k_buf,
  2379.                      addr->personal, &dummy),
  2380.          width - l);
  2381.     if(dummy)
  2382.       fs_give((void **)&dummy);
  2383.  
  2384.     return(TRUE);
  2385.     }
  2386.     else if(addr){
  2387.     char *a_string;
  2388.     int   l;
  2389.  
  2390.     a_string = addr_list_string(addr, NULL, 0);
  2391.     if(l = prefix ? strlen(prefix) : 0)
  2392.       strcpy(s, prefix);
  2393.  
  2394.     istrncpy(s + l, a_string, width - l);
  2395.  
  2396.     fs_give((void **)&a_string);
  2397.     return(TRUE);
  2398.     }
  2399.  
  2400.     return(FALSE);
  2401. }
  2402.  
  2403.  
  2404.  
  2405. long
  2406. line_hash(s)
  2407.      char *s;
  2408. {
  2409.     register long xsum = 0L;
  2410.  
  2411.     while(*s)
  2412.       xsum = ((((xsum << 4) & 0xffffffff) + (xsum >> 24)) & 0x0fffffff) + *s++;
  2413.  
  2414.     return(xsum ? xsum : 1L);
  2415. }
  2416.  
  2417.  
  2418. /*-----
  2419.   The following are used to report on sorting progress to the user
  2420.  
  2421. This code is not ideal as it varies depending on how the mail driver
  2422. performs with respect to fetching envelopes.  For some c-client drivers
  2423. the initial fetch of the envelope is expensive and it is cached after
  2424. that. For others every fetch is expensive.  The code here deals with
  2425. with the case where only the first fetch is expensive. It reports
  2426. progress based on how many messages have been fetched, assuming the sort
  2427. will complete very rapidly when all the messages have been fetched. 
  2428.  
  2429. There is a bitmap that keeps track of which messages have been
  2430. fetched that is used to keep an accurate count of the number of messages
  2431. that have been fetched. The sort algorithm fetches envelopes in a random
  2432. order and possibly many times. 
  2433.  
  2434. For c-client drivers for which every fetch envelope is expensive, this
  2435. algorithm will report that the sort is 100% complete once all the envelopes
  2436. have been fetched at least once.
  2437.   ----*/
  2438.  
  2439. #ifndef DOS
  2440. /*
  2441.  * Bitmap for keeping track of messages fetched so progress of
  2442.  * sort can be reported 
  2443.  */
  2444. static unsigned short *fetched_map;
  2445. static long           fetched_count;
  2446.  
  2447. #define  GET_FETCHED_MAP(x)  (fetched_map[(x-1)/16] & (0x1 << ((x-1) & 0xf)))
  2448. #define  SET_FETCHED_MAP(x)  (fetched_map[(x-1)/16] |= (0x1 << ((x-1) & 0xf)))
  2449.  
  2450.  
  2451. /*
  2452.  * Return value for use by progress bar.
  2453.  */
  2454. int
  2455. percent_sorted()
  2456. {
  2457.     return((fetched_count*100) / mn_get_total(ps_global->msgmap));
  2458. }
  2459. #endif    /* !DOS */
  2460.  
  2461.  
  2462. /*----------------------------------------------------------------------
  2463.   Compare function for sorting on subjects. Ignores case, space and "re:"
  2464.   ----*/
  2465. int
  2466. compare_subjects(a, b)
  2467.     const QSType *a, *b;
  2468. {
  2469.     char *suba, *subb;
  2470.     long *mess_a = (long *)a, *mess_b = (long *)b;
  2471.     int   diff, res;
  2472.     long  mdiff;
  2473.  
  2474.     if(ps_global->intr_pending)
  2475.       longjmp(jump_past_qsort, 1);
  2476.  
  2477.     suba = get_sub(*mess_a);
  2478.     subb = get_sub(*mess_b);
  2479.  
  2480.     diff = strucmp(suba, subb);
  2481.  
  2482.     if(diff == 0)
  2483.       mdiff = *mess_a - *mess_b;
  2484.  
  2485.     /* convert to int */
  2486.     res = diff != 0 ? diff :
  2487.            mdiff != 0L ? (mdiff > 0L ? 1 : -1) : 0;
  2488.     return(mn_get_revsort(ps_global->msgmap) ? -res : res);
  2489. }
  2490.  
  2491.  
  2492. /*----------------------------------------------------------------------
  2493.    Get the subject of a message suitable for sorting.  This removes
  2494.  all re[*]: or [ from the beginning of a message.
  2495.  ----*/
  2496. char *
  2497. get_sub(mess)
  2498.     long mess;
  2499. {
  2500.     ENVELOPE *e;
  2501.     char *subj, *s, *s3, *ss, *dummy = NULL;
  2502.     int   l;
  2503.  
  2504.     if(!(ss = subject_cache_ent(mess))){
  2505.     e = mail_fetchstructure(ps_global->mail_stream, mess, NULL);
  2506.     if(e && e->subject) {
  2507.         /* ---- Deal with any necessary RFC 1522 decoding ----*/
  2508.         subj = (char *)rfc1522_decode((unsigned char *)tmp_20k_buf,
  2509.                       e->subject, &dummy);
  2510.         if(dummy)
  2511.           fs_give((void **)&dummy);
  2512.  
  2513.         /* ---- Clean junk off the front of the subject ----*/
  2514.         for(s = subj; *s && (isspace((unsigned char)*s) || *s == '['); s++)
  2515.           /* do nothing */;
  2516.  
  2517.         if((*s == 'R' || *s == 'r') && (*(s+1) == 'E' || *(s+1) == 'e')
  2518.            && (*(s+2) == ':' || *(s+2) == '[')){
  2519.         s += 3;
  2520.         if(*(s+2) == '['){
  2521.             while(*s && *s != ':')
  2522.               s++;
  2523.  
  2524.             s++;
  2525.         }
  2526.         }
  2527.  
  2528.         while(*s && (isspace((unsigned char)*s) || *s == '['))
  2529.           s++;
  2530.  
  2531.         if(*(ss = subject_cache_add(mess, s))){
  2532.         /*----- Now, truncate junk off the back end of the subject---*/
  2533.         for(s3 = NULL, s = ss; *s; s++)    /* blast ws and ']' */
  2534.           s3 = (!isspace((unsigned char)*s) && *s != ']')
  2535.                           ? NULL : (!s3) ? s : s3;
  2536.  
  2537.         if(s3)
  2538.           *s3 = '\0';
  2539.  
  2540.         if((l=(s3 ? s3 : s)-ss) > 5 && !strucmp(ss+l-5,"(fwd)"))
  2541.           ss[l-5] = '\0';
  2542.  
  2543.         for(s3 = NULL, s = ss; *s; s++)    /* blast ws and ']' */
  2544.           s3 = (!isspace((unsigned char)*s) && *s != ']')
  2545.                           ? NULL : (!s3) ? s : s3;
  2546.  
  2547.         if(s3)
  2548.           *s3 = '\0';
  2549.         }
  2550.     }
  2551.     else
  2552.       ss = subject_cache_add(mess, "");
  2553.  
  2554.     dprint(9, (debugfile, "SUB-GET-%s-GET-SUB\n", ss));
  2555.     }
  2556.     else{
  2557.     dprint(9, (debugfile, "SUB-HIT-%s-HIT-SUB\n", ss));
  2558.     }
  2559.  
  2560. #ifndef DOS
  2561.     if(fetched_map != NULL && !GET_FETCHED_MAP(mess)) {
  2562.         SET_FETCHED_MAP(mess);
  2563.         fetched_count++;
  2564.     }
  2565. #endif
  2566.  
  2567.     ALARM_BLIP();
  2568.  
  2569.     return(ss);
  2570. }
  2571.  
  2572.  
  2573. /*----------------------------------------------------------------------
  2574.    Compare the From: fields for sorting. Ignore case.  Only consider the
  2575.    mailbox portion of the address (part left of @).
  2576.    ----*/
  2577. int 
  2578. compare_from(a, b)
  2579.     const QSType *a, *b;
  2580. {
  2581.     long     *mess_a = (long *)a, *mess_b = (long *)b;
  2582.     ENVELOPE *e;
  2583.     char      froma[200], fromb[200];
  2584.     int       diff, res;
  2585.  
  2586.     if(ps_global->intr_pending)
  2587.       longjmp(jump_past_qsort, 1);
  2588.  
  2589.     e = mail_fetchstructure(ps_global->mail_stream, *mess_a, NULL);
  2590.     if(e == NULL || e->from == NULL || e->from->mailbox == NULL)  
  2591.       froma[0] = '\0';
  2592.     else
  2593.       strncpy(froma, e->from->mailbox, sizeof(froma) - 1);
  2594.  
  2595.     froma[sizeof(froma) - 1] = '\0';
  2596.  
  2597.     e = mail_fetchstructure(ps_global->mail_stream, *mess_b, NULL);
  2598.     if(e == NULL || e->from == NULL || e->from->mailbox == NULL)  
  2599.       fromb[0] = '\0';
  2600.     else
  2601.       strncpy(fromb, e->from->mailbox, sizeof(fromb) - 1);
  2602.  
  2603.     fromb[sizeof(fromb) - 1] = '\0';
  2604.  
  2605. #ifndef DOS
  2606.     if(!GET_FETCHED_MAP(*mess_a)){
  2607.         SET_FETCHED_MAP(*mess_a);
  2608.         fetched_count++;
  2609.     }
  2610.  
  2611.     if(!GET_FETCHED_MAP(*mess_b)){
  2612.         SET_FETCHED_MAP(*mess_b);
  2613.         fetched_count++;
  2614.     }
  2615. #endif
  2616.  
  2617.     ALARM_BLIP();
  2618.  
  2619.     diff = strucmp(froma, fromb);
  2620.     if(diff == 0){
  2621.     long mdiff;
  2622.  
  2623.         mdiff = *mess_a - *mess_b;  /* arrival order */
  2624.     /* convert to int */
  2625.     res = mdiff != 0L ? (mdiff > 0L ? 1 : -1) : 0;
  2626.     }
  2627.     else
  2628.       res = diff;
  2629.     
  2630.     return(mn_get_revsort(ps_global->msgmap) ? -res : res);
  2631. } 
  2632.  
  2633.  
  2634. /*----------------------------------------------------------------------
  2635.    Compare the To: fields for sorting. Ignore case. Use 1st to.
  2636.    ----*/
  2637. int 
  2638. compare_to(a, b)
  2639.     const QSType *a, *b;
  2640. {
  2641.     long     *mess_a = (long *)a, *mess_b = (long *)b;
  2642.     ENVELOPE *e;
  2643.     char      toa[200], tob[200];
  2644.     int       diff, res;
  2645.  
  2646.     if(ps_global->intr_pending)
  2647.       longjmp(jump_past_qsort, 1);
  2648.  
  2649.     e = mail_fetchstructure(ps_global->mail_stream, *mess_a, NULL);
  2650.     if(e == NULL || e->to == NULL || e->to->mailbox == NULL)  
  2651.       toa[0] = '\0';
  2652.     else
  2653.       strncpy(toa, e->to->mailbox, sizeof(toa) - 1);
  2654.  
  2655.     toa[sizeof(toa) - 1] = '\0';
  2656.  
  2657.     e = mail_fetchstructure(ps_global->mail_stream, *mess_b, NULL);
  2658.     if(e == NULL || e->to == NULL || e->to->mailbox == NULL)  
  2659.       tob[0] = '\0';
  2660.     else
  2661.       strncpy(tob, e->to->mailbox, sizeof(tob) - 1);
  2662.  
  2663.     tob[sizeof(tob) - 1] = '\0';
  2664.  
  2665. #ifndef DOS
  2666.     if(!GET_FETCHED_MAP(*mess_a)){
  2667.         SET_FETCHED_MAP(*mess_a);
  2668.         fetched_count++;
  2669.     }
  2670.  
  2671.     if(!GET_FETCHED_MAP(*mess_b)){
  2672.         SET_FETCHED_MAP(*mess_b);
  2673.         fetched_count++;
  2674.     }
  2675. #endif
  2676.  
  2677.     ALARM_BLIP();
  2678.  
  2679.     diff = strucmp(toa, tob);
  2680.     if(diff == 0){
  2681.     long mdiff;
  2682.  
  2683.         mdiff = *mess_a - *mess_b;  /* arrival order */
  2684.     /* convert to int */
  2685.     res = mdiff != 0L ? (mdiff > 0L ? 1 : -1) : 0;
  2686.     }
  2687.     else
  2688.       res = diff;
  2689.     
  2690.     return(mn_get_revsort(ps_global->msgmap) ? -res : res);
  2691. } 
  2692.  
  2693.  
  2694. /*----------------------------------------------------------------------
  2695.    Compare the Cc: fields for sorting. Ignore case. Use 1st cc.
  2696.    ----*/
  2697. int 
  2698. compare_cc(a, b)
  2699.     const QSType *a, *b;
  2700. {
  2701.     long     *mess_a = (long *)a, *mess_b = (long *)b;
  2702.     ENVELOPE *e;
  2703.     char      cca[200], ccb[200];
  2704.     int       diff, res;
  2705.  
  2706.     if(ps_global->intr_pending)
  2707.       longjmp(jump_past_qsort, 1);
  2708.  
  2709.     e = mail_fetchstructure(ps_global->mail_stream, *mess_a, NULL);
  2710.     if(e == NULL || e->cc == NULL || e->cc->mailbox == NULL)  
  2711.       cca[0] = '\0';
  2712.     else
  2713.       strncpy(cca, e->cc->mailbox, sizeof(cca) - 1);
  2714.  
  2715.     cca[sizeof(cca) - 1] = '\0';
  2716.  
  2717.     e = mail_fetchstructure(ps_global->mail_stream, *mess_b, NULL);
  2718.     if(e == NULL || e->cc == NULL || e->cc->mailbox == NULL)  
  2719.       ccb[0] = '\0';
  2720.     else
  2721.       strncpy(ccb, e->cc->mailbox, sizeof(ccb) - 1);
  2722.  
  2723.     ccb[sizeof(ccb) - 1] = '\0';
  2724.  
  2725. #ifndef DOS
  2726.     if(!GET_FETCHED_MAP(*mess_a)){
  2727.         SET_FETCHED_MAP(*mess_a);
  2728.         fetched_count++;
  2729.     }
  2730.  
  2731.     if(!GET_FETCHED_MAP(*mess_b)){
  2732.         SET_FETCHED_MAP(*mess_b);
  2733.         fetched_count++;
  2734.     }
  2735. #endif
  2736.  
  2737.     ALARM_BLIP();
  2738.  
  2739.     diff = strucmp(cca, ccb);
  2740.     if(diff == 0){
  2741.     long mdiff;
  2742.  
  2743.         mdiff = *mess_a - *mess_b;  /* arrival order */
  2744.     /* convert to int */
  2745.     res = mdiff != 0L ? (mdiff > 0L ? 1 : -1) : 0;
  2746.     }
  2747.     else
  2748.       res = diff;
  2749.     
  2750.     return(mn_get_revsort(ps_global->msgmap) ? -res : res);
  2751. } 
  2752.  
  2753.  
  2754. /*----------------------------------------------------------------------
  2755.    Compare dates (not arrival times, but time from Date header)
  2756.   ----*/
  2757. int
  2758. compare_message_dates(a, b)
  2759.     const QSType *a, *b;
  2760. {
  2761.     long        *mess_a = (long *)a, *mess_b = (long *)b;
  2762.     int          diff, res;
  2763.     long         mdiff;
  2764.     ENVELOPE    *e;
  2765.     MESSAGECACHE mc_a, mc_b;
  2766.  
  2767.     if(ps_global->intr_pending)
  2768.       longjmp(jump_past_qsort, 1);
  2769.  
  2770.     mdiff = *mess_a - *mess_b;
  2771.     res = mdiff != 0L ? (mdiff > 0L ? 1 : -1) : 0;
  2772.  
  2773.     mc_a.minutes   = mc_b.minutes = 0;        /* init interesting bits */
  2774.     mc_a.hours       = mc_b.hours = 0;
  2775.     mc_a.day       = mc_b.day = 0;
  2776.     mc_a.month       = mc_b.month = 0;
  2777.     mc_a.year       = mc_b.year = 0;
  2778.     mc_a.zhours       = mc_b.zhours = 0;
  2779.     mc_a.zminutes  = mc_b.zminutes = 0;
  2780.     mc_a.zoccident = mc_b.zoccident = 0;
  2781.  
  2782.     e = mail_fetchstructure(ps_global->mail_stream, *mess_a, NULL);
  2783.     mc_a.valid = (e && e->date && mail_parse_date(&mc_a, e->date));
  2784.  
  2785.     e = mail_fetchstructure(ps_global->mail_stream, *mess_b, NULL);
  2786.     mc_b.valid = (e && e->date && mail_parse_date(&mc_b, e->date));
  2787.  
  2788.     if(!mc_a.valid)
  2789.       return((mn_get_revsort(ps_global->msgmap) ? -1 : 1)
  2790.           * (mc_b.valid ? -1 : res));
  2791.     else if(!mc_b.valid)
  2792.       return(mn_get_revsort(ps_global->msgmap) ? -1 : 1);
  2793.  
  2794.     diff = compare_dates(&mc_a, &mc_b);
  2795.  
  2796. #ifndef DOS
  2797.     if(!GET_FETCHED_MAP(*mess_a)){
  2798.         SET_FETCHED_MAP(*mess_a);
  2799.         fetched_count++;
  2800.     }
  2801.  
  2802.     if(!GET_FETCHED_MAP(*mess_b)){
  2803.         SET_FETCHED_MAP(*mess_b);
  2804.         fetched_count++;
  2805.     }
  2806. #endif
  2807.  
  2808.     ALARM_BLIP();
  2809.     
  2810.     res = diff != 0 ? diff : res;
  2811.     return(mn_get_revsort(ps_global->msgmap) ? -res : res);
  2812. }
  2813.  
  2814.     
  2815.  
  2816. /*----------------------------------------------------------------------
  2817.   Compare size of messages for sorting
  2818.  ----*/
  2819. int
  2820. compare_size(a, b)
  2821.     const QSType *a, *b;
  2822. {
  2823.     long      *mess_a = (long *)a, *mess_b = (long *)b;
  2824.     long      size_a, size_b, sdiff, mdiff;
  2825.     MESSAGECACHE *mc;
  2826.     int          res;
  2827.  
  2828.     if(ps_global->intr_pending)
  2829.       longjmp(jump_past_qsort, 1);
  2830.  
  2831.     mail_fetchstructure(ps_global->mail_stream, *mess_a, NULL);
  2832.     mc = mail_elt(ps_global->mail_stream, *mess_a);
  2833.     size_a = mc != NULL ? mc->rfc822_size : -1L;
  2834.  
  2835.     mail_fetchstructure(ps_global->mail_stream, *mess_b, NULL);
  2836.     mc = mail_elt(ps_global->mail_stream, *mess_b);
  2837.     size_b = mc != NULL ? mc->rfc822_size : -1L;
  2838.  
  2839. #ifndef DOS
  2840.     if(!GET_FETCHED_MAP(*mess_a)){
  2841.         SET_FETCHED_MAP(*mess_a);
  2842.         fetched_count++;
  2843.     }
  2844.  
  2845.     if(!GET_FETCHED_MAP(*mess_b)){
  2846.         SET_FETCHED_MAP(*mess_b);
  2847.         fetched_count++;
  2848.     }
  2849. #endif    
  2850.  
  2851.     ALARM_BLIP();
  2852.  
  2853.     sdiff = size_a - size_b;
  2854.     if(sdiff == 0L)
  2855.       mdiff = *mess_a - *mess_b;
  2856.  
  2857.     /* convert to int */
  2858.     res = sdiff != 0L ? (sdiff > 0L ? 1 : -1) :
  2859.            mdiff != 0L ? (mdiff > 0L ? 1 : -1) : 0;
  2860.     return(mn_get_revsort(ps_global->msgmap) ? -res : res);
  2861. }
  2862.  
  2863.  
  2864. /*----------------------------------------------------------------------
  2865.   Compare raw message numbers 
  2866.  ----*/
  2867. int
  2868. compare_arrival(a, b)
  2869.     const QSType *a, *b;
  2870. {
  2871.     long *mess_a = (long *)a, *mess_b = (long *)b, mdiff;
  2872.     int   res;
  2873.  
  2874.     res = (mdiff = *mess_a - *mess_b) ? (mdiff > 0L ? 1 : -1) : 0;
  2875.     return(mn_get_revsort(ps_global->msgmap) ? -res : res);
  2876. }
  2877.  
  2878.  
  2879. #if    defined(DOS) && !defined(_WINDOWS)
  2880. static FILE *second_sort_file;    /* Can't afford an array with DOS */
  2881. static char *second_sort_file_name = NULL;
  2882. #else
  2883. static long *second_sort;    /* Array of message numbers */
  2884. #endif
  2885.  
  2886. /*----------------------------------------------------------------------
  2887.    Each message is in a subject group.  That group is indexed by the
  2888.    Date of its oldest member.  Sort first by that date, and within a
  2889.    single subject group, sort by Date of each message.
  2890.   ----*/
  2891. int
  2892. compare_subject_2(a, b)
  2893.     const QSType *a, *b;
  2894. {
  2895.     long       *mess_a = (long *)a, *mess_b = (long *)b;
  2896.     long        a1, b1;
  2897.     long        diff;
  2898.     int         res;
  2899.  
  2900.     if(ps_global->intr_pending)
  2901.       longjmp(jump_past_qsort, 1);
  2902.  
  2903. #if    defined(DOS) && !defined(_WINDOWS)
  2904.     /* There ought to be a better way than seeking all over 
  2905.        the disk, but too lazy at the moment */
  2906.     fseek(second_sort_file, *mess_a * sizeof(long), 0);
  2907.     fread((void *)&a1, sizeof(a1), (size_t)1, second_sort_file);
  2908.     fseek(second_sort_file, *mess_b * sizeof(long), 0);
  2909.     fread((void *)&b1, sizeof(b1), (size_t)1, second_sort_file);
  2910. #else
  2911.     a1 = second_sort[*mess_a];
  2912.     b1 = second_sort[*mess_b];
  2913. #endif
  2914.     
  2915.     diff = a1 - b1;
  2916.  
  2917.     /*
  2918.      * Note, secondary sort is by Date instead of by arrival time as
  2919.      * with most of the other compare functions.
  2920.      */
  2921.     res = diff != 0L ? (diff > 0L ? 1 : -1) : compare_message_dates(a, b);
  2922.  
  2923.     return((mn_get_revsort(ps_global->msgmap) && diff != 0L) ? -res : res);
  2924. }
  2925.  
  2926.  
  2927.     
  2928. /*----------------------------------------------------------------------
  2929.      Sort messages on subject, grouping subjects by date of oldest member
  2930.  
  2931. Args: sort -- The resulting sorted array of message numbers
  2932.       max_msgno -- The number of messages in this view
  2933.       total_max -- The largest possible message number
  2934.  
  2935. This is the OrderedSubjectSort style of subject sort akin to message threading
  2936. based on subject.  All the subjects are grouped together and then the 
  2937. groups are ordered based on the oldest message in each group. 
  2938.  
  2939. Here the groups of subjects are sorted.  Before calling this function,
  2940. the messages have been sorted by subject.
  2941.  
  2942. The second array is indexed by raw message numbers and contains the
  2943. the date (in seconds) of the oldest message in the same subject group.
  2944.  
  2945. This code could be used to calculate information for true
  2946. message threading.  For example, a data structure that had one entry
  2947. per unique subject.  The data structure would probably only need to contain
  2948. the *sorted* message number of the first message in the thread and the 
  2949. number of messages in the thread. That would be assuming that the sort
  2950. array is sorted in the appropriate order. 
  2951.  
  2952. On DOS where memory is expensive the secondary array is a disk file instead
  2953. of being in memory. (Though for many formats sorting on DOS will be 
  2954. extremely painful until some local caching of sort terms is invented.)
  2955.  ----*/
  2956. void
  2957. second_subject_sort(sort, max_msgno, total_max)
  2958.     long *sort, max_msgno, total_max;
  2959. {
  2960.     char  *sub_group, *sub;
  2961.     long   start_sub_group, m, s, t, min_sub_group_date;
  2962.     long   for_zero_dates = 0L;
  2963.     int    check_again;
  2964.  
  2965.     if(max_msgno < 1 || total_max < 1)
  2966.       return; 
  2967.  
  2968. #if    defined(DOS) && !defined(_WINDOWS)
  2969.     second_sort_file_name = temp_nam(NULL, "sf");
  2970.     second_sort_file      = fopen(second_sort_file_name, "wb+");
  2971. #else
  2972.     second_sort      = (long *)fs_get(sizeof(long) * (size_t)(total_max + 1));
  2973. #endif
  2974.  
  2975.     /* init for loop */
  2976.     sub_group          = get_sub(sort[1]);
  2977.     start_sub_group    = 1;
  2978.     min_sub_group_date = seconds_since_epoch(sort[1]);
  2979.     /*
  2980.      * This is so that unparseable dates won't all be the same.  That would
  2981.      * make it look like they're all in the same subject group.
  2982.      */
  2983.     if(min_sub_group_date == 0){
  2984.     for_zero_dates += 10;
  2985.     min_sub_group_date = for_zero_dates;
  2986.     }
  2987.  
  2988.     /*
  2989.      * Create the second array of subject groups.  The sort array had to be
  2990.      * sorted by subject before this function was called, so that each
  2991.      * subject group would be contiguous in the array.  (Didn't actually have
  2992.      * to be sorted, just contiguous subject groups in any order.)
  2993.      */
  2994.     for(s = 2; s <= max_msgno; s++){
  2995.     sub = get_sub(sort[s]);
  2996.         if(strucmp(sub_group, sub)){ /* new subject */
  2997.         /* record the previous group */
  2998. #if    !defined(DOS) || defined(_WINDOWS)
  2999.         /*
  3000.          * If two different groups both have the same min_sub_group_date,
  3001.          * then they'll get mushed together when we sort.  We want to make
  3002.          * sure that doesn't happen, so we need to check if this date
  3003.          * is already recorded somewhere in second_sort and change it
  3004.          * if it is.
  3005.          *
  3006.          * (Too expensive for DOS, count on it being very rare.)
  3007.          */
  3008.         check_again = 1;
  3009.         while(check_again){
  3010.         check_again = 0;
  3011.         for(m = 1; m < start_sub_group; m++){
  3012.             if(min_sub_group_date == second_sort[sort[m]]){
  3013.             min_sub_group_date++;
  3014.             check_again = 1;
  3015.             break;
  3016.             }
  3017.         }
  3018.         }
  3019. #endif
  3020.             for(t = start_sub_group; t < s; t++){
  3021. #if    defined(DOS) && !defined(_WINDOWS)
  3022.                 fseek(second_sort_file, sort[t] * sizeof(long), 0);
  3023.                 fwrite((void *)&min_sub_group_date,
  3024.                        sizeof(min_sub_group_date),
  3025.                        (size_t)1,  second_sort_file);
  3026. #else
  3027.         second_sort[sort[t]] = min_sub_group_date;
  3028. #endif                
  3029.         }
  3030.  
  3031.         /* reset for next subject */
  3032.             start_sub_group     = s;
  3033.             sub_group           = sub;
  3034.         }
  3035.  
  3036.     if(s > start_sub_group)
  3037.       min_sub_group_date =
  3038.         min(min_sub_group_date, seconds_since_epoch(sort[s]));
  3039.     else /* new subject */
  3040.       min_sub_group_date = seconds_since_epoch(sort[s]);
  3041.  
  3042.     if(min_sub_group_date == 0){
  3043.         for_zero_dates += 10;
  3044.         min_sub_group_date = for_zero_dates;
  3045.     }
  3046.     }
  3047.  
  3048.     /* record final group */
  3049. #if    !defined(DOS) || defined(_WINDOWS)
  3050.     check_again = 1;
  3051.     while(check_again){
  3052.         check_again = 0;
  3053.         for(m = 1; m < start_sub_group; m++){
  3054.         if(min_sub_group_date == second_sort[sort[m]]){
  3055.             min_sub_group_date++;
  3056.             check_again = 1;
  3057.             break;
  3058.         }
  3059.         }
  3060.     }
  3061. #endif
  3062.  
  3063.     for(t = start_sub_group; t < s; t++){
  3064. #if    defined(DOS) && !defined(_WINDOWS)
  3065.         fseek(second_sort_file, sort[t] * sizeof(long), 0);
  3066.         fwrite((void *)&min_sub_group_date, sizeof(min_sub_group_date),
  3067.                        (size_t)1,  second_sort_file);
  3068. #else
  3069.     second_sort[sort[t]] = min_sub_group_date;
  3070. #endif
  3071.     }
  3072.  
  3073. #ifdef DEBUG
  3074.     for(t = 1; t <= max_msgno; t++) 
  3075.       dprint(9, (debugfile, "Second_sort[%3ld] is %3ld\n", t, second_sort[t]));
  3076. #endif
  3077.  
  3078.     /* Actually perform the sort */
  3079.     qsort(sort+1, (size_t)max_msgno, sizeof(long), compare_subject_2);
  3080.  
  3081.     /* Clean up */
  3082. #if    defined(DOS) && !defined(_WINDOWS)
  3083.     fclose(second_sort_file);
  3084.     unlink(second_sort_file_name);
  3085.     fs_give((void **)&second_sort_file_name);
  3086. #else    
  3087.     fs_give((void **)&second_sort);
  3088. #endif
  3089. }
  3090.  
  3091.  
  3092. /*
  3093.  * This is just used to help with the OrderedSubjSort.
  3094.  * The argument is a raw message number and the return value is the number
  3095.  * of seconds between the start of the BASEYEAR (1969) and the date in the
  3096.  * Date header.  Returns 0 if date can't be parsed or no date.
  3097.  */
  3098. long
  3099. seconds_since_epoch(msgno)
  3100. long msgno;
  3101. {
  3102.     ENVELOPE    *e;
  3103.     MESSAGECACHE mc;
  3104.     long seconds = 0L;
  3105.     int y, m;
  3106.  
  3107. #define MINUTE       (60L)
  3108. #define HOUR         (60L * MINUTE)
  3109. #define DAY          (24L * HOUR)
  3110. #define MONTH(mo,yr) ((long)days_in_month(mo,yr) * DAY)
  3111. #define YEAR(yr)     (((!((yr)%4L) && ((yr)%100L)) ? 366L : 365L) * DAY)
  3112.  
  3113.     e = mail_fetchstructure(ps_global->mail_stream, msgno, NULL);
  3114.     if(e == NULL || e->date == NULL)
  3115.       return(0L);
  3116.  
  3117.     if(!mail_parse_date(&mc, e->date))
  3118.       return(0L);
  3119.  
  3120.     convert_to_gmt(&mc);
  3121.  
  3122.     for(y = 0; (unsigned)y < mc.year; y++)
  3123.       seconds += YEAR(y+BASEYEAR);
  3124.  
  3125.     for(m = 1; (unsigned)m < mc.month; m++)
  3126.       seconds += MONTH(m, mc.year + BASEYEAR);
  3127.     
  3128.     seconds +=
  3129.     ((mc.day-1) * DAY + mc.hours * HOUR + mc.minutes * MINUTE + mc.seconds);
  3130.  
  3131.     return(seconds);
  3132. }
  3133.  
  3134.  
  3135. /*----------------------------------------------------------------------
  3136.     Sort the current folder into the order set in the msgmap
  3137.  
  3138. Args: defer_on_intr   -- If we get interrupted before finishing, set the
  3139.               deferred variable.
  3140.       default_so      -- If we get interrupted before finishing, set the
  3141.               sort order to default_so.
  3142.       default_reverse -- If we get interrupted before finishing, set the
  3143.               revsort to default_reverse.
  3144.     
  3145.     The idea of the deferred sort is to let the user interrupt a long sort
  3146.     and have a chance to do a different command, such as a sort by arrival
  3147.     or a Goto.  The next newmail call will increment the deferred variable,
  3148.     then the user may do a command, then the newmail call after that
  3149.     causes the sort to happen if it is still needed.
  3150.   ----*/
  3151. void
  3152. sort_current_folder(defer_on_intr, default_so, default_reverse)
  3153.     int defer_on_intr;
  3154.     SortOrder default_so;
  3155.     int default_reverse;
  3156. {
  3157.     long        i, *sort, *saved_sort, total = mn_get_total(ps_global->msgmap);
  3158.     MSGNO_S    *sortmap = NULL;
  3159.     SortOrder   so;
  3160.     char        sort_msg[101];
  3161.     int         skip_qsort = 0, we_cancel = 0, rev, is_default_order;
  3162.  
  3163.     so = mn_get_sort(ps_global->msgmap);    /* current sort order */
  3164.     rev = mn_get_revsort(ps_global->msgmap);    /* currently reverse? */
  3165.     /*
  3166.      * If is_default_order, that means we aren't changing the sort order,
  3167.      * we're just sorting because we may have gotten new mail or unexcluded
  3168.      * some mail that was hidden.
  3169.      */
  3170.     is_default_order = (so == default_so && rev == default_reverse);
  3171.     if(!ps_global->msgmap || !(sort = ps_global->msgmap->sort))
  3172.       return;
  3173.  
  3174.     dprint(2, (debugfile, "Sorting by %s%s\n", sort_name(so),
  3175.            mn_get_revsort(ps_global->msgmap) ? "/reverse" : ""));
  3176.  
  3177.     /*
  3178.      * translate the selected numbers into an array of raw numbers
  3179.      * temporarily, then translate it back after the sort so the
  3180.      * same physical messages are selected...
  3181.      */
  3182.     mn_init(&sortmap, 0L);
  3183.     mn_set_cur(sortmap, mn_m2raw(ps_global->msgmap,
  3184.                  mn_first_cur(ps_global->msgmap)));
  3185.     while((i = mn_next_cur(ps_global->msgmap)) > 0L)
  3186.       mn_add_cur(sortmap, mn_m2raw(ps_global->msgmap, i));
  3187.  
  3188.     if(so == SortArrival){
  3189.     /*
  3190.      * BEWARE: "exclusion" may leave holes in the unsorted sort order
  3191.      * so we have to do a real sort if that is the case.
  3192.      */
  3193.     if(any_lflagged(ps_global->msgmap, MN_EXLD))
  3194.       qsort(sort+1, (size_t) total, sizeof(long), compare_arrival);
  3195.     else
  3196.       for(i = 1L; i <= total; i++)
  3197.         sort[i] = mn_get_revsort(ps_global->msgmap) ? (total + 1 - i) : i;
  3198.     }
  3199.     else{
  3200.         if(so == SortSubject || so == SortSubject2)    /* nmsgs cuz MN_EXLD */
  3201.       init_subject_cache(ps_global->mail_stream->nmsgs);
  3202.  
  3203.         /*========= Sorting ================================================*/
  3204. #ifndef DOS
  3205.         /*--- fetched map for keep track of progress of sort ----*/
  3206.         fetched_count = 0;
  3207.         fetched_map   = (unsigned short *)fs_get(
  3208.                          (ps_global->mail_stream->nmsgs/16 + 1)
  3209.                                               * sizeof(unsigned short));
  3210.     memset((void *)fetched_map, 0,
  3211.         (ps_global->mail_stream->nmsgs/16 + 1) * sizeof(unsigned short));
  3212. #endif
  3213.  
  3214.  
  3215. #ifdef DOS
  3216.     sprintf(sort_msg, "Sorting \"%.90s\"", ps_global->cur_folder);
  3217.     we_cancel = busy_alarm(1, sort_msg, NULL, 1);
  3218. #else
  3219.     sprintf(sort_msg, "Sorting \"%.90s\"", ps_global->cur_folder);
  3220.     we_cancel = busy_alarm(1, sort_msg, percent_sorted, 1);
  3221.  
  3222.     /*
  3223.      * Interruptible sorting is only available under unix where we
  3224.      * can rely on the tty driver to deliver the SIGINT.  If we
  3225.      * can safely work out a similar scheme under windows/max, this
  3226.      * #ifdef will have to get rearranged...
  3227.      */
  3228.     /* save array in case of interrupt */
  3229.     saved_sort
  3230.         = (long *)fs_get(ps_global->msgmap->sort_size * sizeof(long));
  3231.     for(i = 1L; i <= total; i++)
  3232.       saved_sort[i] = sort[i];
  3233.  
  3234.     if(setjmp(jump_past_qsort)){
  3235.         intr_handling_off();
  3236.         if(we_cancel)
  3237.           cancel_busy_alarm(-1);
  3238.  
  3239.         we_cancel = 0;
  3240.         skip_qsort = 1;
  3241.         /* restore default SortOrder */
  3242.         mn_set_sort(ps_global->msgmap, default_so);
  3243.         mn_set_revsort(ps_global->msgmap, default_reverse);
  3244.         /* restore sort array */
  3245.         for(i = 1L; i <= total; i++)
  3246.           sort[i] = saved_sort[i];
  3247.  
  3248.         fs_give((void **)&saved_sort); 
  3249.     }
  3250. #endif
  3251.  
  3252.     if(!skip_qsort){
  3253. #ifndef    DOS
  3254.         intr_handling_on();
  3255. #endif
  3256.  
  3257.         qsort(sort + 1, (size_t) total, sizeof(long),
  3258.           so == SortSubject  ? compare_subjects :
  3259.            so == SortFrom     ? compare_from :
  3260.             so == SortTo       ? compare_to :
  3261.              so == SortCc       ? compare_cc :
  3262.               so == SortDate     ? compare_message_dates :
  3263.                so == SortSubject2 ? compare_subjects:
  3264.                                          compare_size);
  3265.  
  3266.         /*---- special case -- reorder the groups of subjects ------*/
  3267.         if(so == SortSubject2) 
  3268.           second_subject_sort(sort, total, ps_global->mail_stream->nmsgs);
  3269. #ifndef    DOS
  3270.         intr_handling_off();
  3271.         fs_give((void **)&saved_sort); 
  3272. #endif
  3273.     }
  3274.  
  3275.     if(we_cancel)
  3276.       cancel_busy_alarm(1);
  3277.  
  3278.     if(skip_qsort)
  3279.       q_status_message3(SM_ORDER, 3, 3, "Sort cancelled%s%s%s",
  3280.           is_default_order ? "" : "; now sorting by ",
  3281.           is_default_order ? "" : sort_name(default_so),
  3282.           is_default_order ? "" : default_reverse ? "/reverse" : "");
  3283.  
  3284. #ifndef DOS
  3285.         fs_give((void **)&fetched_map); 
  3286. #endif
  3287.     clear_subject_cache();
  3288.     }
  3289.  
  3290.     if(skip_qsort)
  3291.       ps_global->unsorted_newmail = 1;
  3292.     else{
  3293.     ps_global->sort_is_deferred = 0;
  3294.     ps_global->unsorted_newmail = 0;
  3295.     }
  3296.  
  3297.     /*
  3298.      * restore the selected array of message numbers.  No expunge could
  3299.      * have happened yet, so we don't worry about raw2m returning 0...
  3300.      */
  3301.     mn_reset_cur(ps_global->msgmap, mn_raw2m(ps_global->msgmap,
  3302.                          mn_first_cur(sortmap)));
  3303.     while((i = mn_next_cur(sortmap)) > 0L)
  3304.       mn_add_cur(ps_global->msgmap, mn_raw2m(ps_global->msgmap, i));
  3305.  
  3306.     mn_give(&sortmap);
  3307. }
  3308.  
  3309.  
  3310. /*----------------------------------------------------------------------
  3311.     Map sort types to names
  3312.   ----*/
  3313. char *    
  3314. sort_name(so)
  3315.   SortOrder so;
  3316. {
  3317.     /*
  3318.      * Make sure the first upper case letter of any new sort name is
  3319.      * unique.  The command char and label for sort selection is 
  3320.      * derived from this name and its first upper case character.
  3321.      * See mailcmd.c:select_sort().
  3322.      */
  3323.     return((so == SortArrival)  ? "Arrival" :
  3324.         (so == SortDate)     ? "Date" :
  3325.          (so == SortSubject)  ? "Subject" :
  3326.           (so == SortCc)       ? "Cc" :
  3327.            (so == SortFrom)        ? "From" :
  3328.         (so == SortTo)         ? "To" :
  3329.          (so == SortSize)     ? "siZe" :
  3330.           (so == SortSubject2) ? "OrderedSubj" :
  3331.                       "BOTCH");
  3332. }
  3333.  
  3334.  
  3335.  
  3336. /*----------------------------------------------------------------------
  3337.     initialize the subject cache
  3338.   ----*/
  3339. void
  3340. init_subject_cache(n)
  3341.     long n;
  3342. {
  3343.     scache = (struct scache *) fs_get(sizeof(struct scache));
  3344.     memset((void *)scache, 0, sizeof(struct scache));
  3345.     scache->size = n;
  3346. #if    defined(DOS) && !defined(_WINDOWS)
  3347.     scache->cname = temp_nam(NULL, "sc");
  3348.     scache->cfile = fopen(scache->cname, "wb+");
  3349.     /* BUG? go into non-caching mode if failure below? */
  3350.     while(n-- >= 0L){
  3351.     if(fwrite(&scache->ent[1], sizeof(scache_ent), (size_t)1,
  3352.           scache->cfile) != 1){
  3353.         sprintf(tmp_20k_buf, "subject cache: %s",
  3354.             error_description(errno));
  3355.         fatal(tmp_20k_buf);
  3356.     }
  3357.     }
  3358. #else
  3359.     scache->ent  = (char **)fs_get((size_t)(n+1L) * sizeof(char *));
  3360.     memset((void *)scache->ent, 0, (size_t)(n+1L) * sizeof(char *));
  3361. #endif
  3362. }
  3363.  
  3364.  
  3365. /*----------------------------------------------------------------------
  3366.     return the subject of the given number if it's in the cache, else NULL
  3367.   ----*/
  3368. char *
  3369. subject_cache_ent(n)
  3370.     long n;
  3371. {
  3372. #if    defined(DOS) && !defined(_WINDOWS)
  3373.     char *buf;
  3374.     int   i;
  3375.  
  3376.     /* if the one we want's in core, return it */
  3377.     buf = (scache->msgno[i=0] == n || scache->msgno[i=1] == n)
  3378.         ? scache->ent[i].buf : NULL;
  3379.  
  3380.     /* else pick one of the slots, and fetch n's subject off disk */
  3381.     if(!buf){
  3382.     i = subject_cache_slot(n);
  3383.     buf = scache->ent[i].used ? scache->ent[i].buf : NULL;
  3384.     }
  3385.  
  3386.     scache->last = i;
  3387.     return(buf);
  3388. #else
  3389.     return(scache->ent[n]);
  3390. #endif
  3391. }
  3392.  
  3393.  
  3394. /*----------------------------------------------------------------------
  3395.     add the given subject to the cache
  3396.   ----*/
  3397. char *
  3398. subject_cache_add(n, s)
  3399.     long n;
  3400.     char *s;
  3401. {
  3402. #if    defined(DOS) && !defined(_WINDOWS)
  3403.     int i;
  3404.     
  3405.     if(scache->msgno[i=0] != n && scache->msgno[i=1] != n)
  3406.       i = subject_cache_slot(n);
  3407.  
  3408.     scache->last = i;
  3409.     scache->ent[i].used = 1;
  3410.     scache->msgno[i] = n;
  3411.     strncpy(scache->ent[i].buf, s, SUB_CACHE_LEN-1);
  3412.     scache->ent[i].buf[SUB_CACHE_LEN-1] = '\0';
  3413.     return(scache->ent[i].buf);
  3414. #else
  3415.     return(scache->ent[n] = cpystr(s));
  3416. #endif
  3417. }
  3418.  
  3419.  
  3420. /*----------------------------------------------------------------------
  3421.     pick the next slot, and fetch n's subject off disk
  3422.   ----*/
  3423. int
  3424. subject_cache_slot(n)
  3425.     long n;
  3426. {
  3427. #if    defined(DOS) && !defined(_WINDOWS)
  3428.     int i;
  3429.  
  3430.     i = scache->last ? 0 : 1;
  3431.     if(scache->msgno[i]){
  3432.     fseek(scache->cfile, scache->msgno[i] * sizeof(scache_ent), 0);
  3433.     fwrite(&scache->ent[i], sizeof(scache_ent), (size_t)1,
  3434.            scache->cfile);
  3435.     }
  3436.  
  3437.     scache->msgno[i] = n;
  3438.     if(fseek(scache->cfile, scache->msgno[i] * sizeof(scache_ent), 0)
  3439.        || fread(&scache->ent[i], sizeof(scache_ent), (size_t)1,
  3440.         scache->cfile) != 1){
  3441.     sprintf(tmp_20k_buf, "Can't access subject cache: ",
  3442.         error_description(errno));
  3443.     fatal(tmp_20k_buf);
  3444.     }
  3445.  
  3446.     return(i);
  3447. #endif
  3448. }
  3449.  
  3450.  
  3451. /*----------------------------------------------------------------------
  3452.     flush the subject cache
  3453.   ----*/
  3454. void
  3455. clear_subject_cache()
  3456. {
  3457.     if(scache){
  3458. #if    defined(DOS) && !defined(_WINDOWS)
  3459.     fclose(scache->cfile);
  3460.     unlink(scache->cname);
  3461.     fs_give((void **)&scache->cname);
  3462. #else
  3463.     for(; scache->size; scache->size--)
  3464.       if(scache->ent[scache->size])
  3465.         fs_give((void **)&scache->ent[scache->size]);
  3466.  
  3467.     if(scache->ent)
  3468.       fs_give((void **)&scache->ent);
  3469.  
  3470. #endif
  3471.     fs_give((void **)&scache);
  3472.     }
  3473. }
  3474.  
  3475.  
  3476.  
  3477. /*
  3478.  *           * * *  Message number management functions  * * *
  3479.  */
  3480.  
  3481.  
  3482. /*----------------------------------------------------------------------
  3483.   Initialize a message manipulation structure for the given total
  3484.  
  3485.    Accepts: msgs - pointer to message manipulation struct
  3486.         n - number to test
  3487.    Returns: true if n is in selected array, false otherwise
  3488.  
  3489.   ----*/
  3490. void
  3491. msgno_init(msgs, tot)
  3492.      MSGNO_S **msgs;
  3493.      long      tot;
  3494. {
  3495.     long   slop = (tot + 1L) % 64;
  3496.     size_t len;
  3497.  
  3498.     if(!msgs)
  3499.       return;
  3500.  
  3501.     if(!(*msgs)){
  3502.     (*msgs) = (MSGNO_S *)fs_get(sizeof(MSGNO_S));
  3503.     memset((void *)(*msgs), 0, sizeof(MSGNO_S));
  3504.     }
  3505.  
  3506.     (*msgs)->sel_cur  = 0L;
  3507.     (*msgs)->sel_cnt  = 1L;
  3508.     (*msgs)->sel_size = 8L;
  3509.     len              = (size_t)(*msgs)->sel_size * sizeof(long);
  3510.     if((*msgs)->select)
  3511.       fs_resize((void **)&((*msgs)->select), len);
  3512.     else
  3513.       (*msgs)->select = (long *)fs_get(len);
  3514.  
  3515.     (*msgs)->select[0] = (tot) ? 1L : 0L;
  3516.  
  3517.     (*msgs)->sort_size = (tot + 1L) + (64 - slop);
  3518.     len               = (size_t)(*msgs)->sort_size * sizeof(long);
  3519.     if((*msgs)->sort)
  3520.       fs_resize((void **)&((*msgs)->sort), len);
  3521.     else
  3522.       (*msgs)->sort = (long *)fs_get(len);
  3523.  
  3524.     memset((void *)(*msgs)->sort, 0, len);
  3525.     for(slop = 1L ; slop <= tot; slop++)    /* reusing "slop" */
  3526.       (*msgs)->sort[slop] = slop;
  3527.  
  3528.     (*msgs)->max_msgno    = tot;
  3529.     (*msgs)->sort_order   = ps_global->def_sort;
  3530.     (*msgs)->reverse_sort = ps_global->def_sort_rev;
  3531.     (*msgs)->flagged_hid  = 0L;
  3532.     (*msgs)->flagged_exld = 0L;
  3533.     (*msgs)->flagged_tmp  = 0L;
  3534. }
  3535.  
  3536.  
  3537.  
  3538. /*----------------------------------------------------------------------
  3539.  Increment the current message number
  3540.  
  3541.    Accepts: msgs - pointer to message manipulation struct
  3542.   ----*/
  3543. void
  3544. msgno_inc(stream, msgs)
  3545.      MAILSTREAM *stream;
  3546.      MSGNO_S    *msgs;
  3547. {
  3548.     long i;
  3549.  
  3550.     if(!msgs || mn_get_total(msgs) < 1L)
  3551.       return;
  3552.  
  3553.     for(i = msgs->select[msgs->sel_cur] + 1; i <= mn_get_total(msgs); i++){
  3554.     if(!get_lflag(stream, msgs, i, MN_HIDE)){
  3555.         (msgs)->select[((msgs)->sel_cur)] = i;
  3556.         break;
  3557.     }
  3558.     }
  3559. }
  3560.  
  3561.  
  3562.  
  3563. /*----------------------------------------------------------------------
  3564.   Decrement the current message number
  3565.  
  3566.    Accepts: msgs - pointer to message manipulation struct
  3567.   ----*/
  3568. void
  3569. msgno_dec(stream, msgs)
  3570.      MAILSTREAM *stream;
  3571.      MSGNO_S     *msgs;
  3572. {
  3573.     long i;
  3574.  
  3575.     if(!msgs || mn_get_total(msgs) < 1L)
  3576.       return;
  3577.  
  3578.     for(i = (msgs)->select[((msgs)->sel_cur)] - 1L; i >= 1L; i--){
  3579.     if(!get_lflag(stream, msgs, i, MN_HIDE)){
  3580.         (msgs)->select[((msgs)->sel_cur)] = i;
  3581.         break;
  3582.     }
  3583.     }
  3584. }
  3585.  
  3586.  
  3587.  
  3588. /*----------------------------------------------------------------------
  3589.   Got thru the message mapping table, and remove messages with DELETED flag
  3590.  
  3591.    Accepts: stream -- mail stream to removed message references from
  3592.         msgs -- pointer to message manipulation struct
  3593.         f -- flags to use a purge criteria
  3594.   ----*/
  3595. void
  3596. msgno_exclude(stream, msgs)
  3597.      MAILSTREAM *stream;
  3598.      MSGNO_S     *msgs;
  3599. {
  3600.     long      i, j;
  3601.  
  3602.     if(!msgs || msgs->max_msgno < 1L)
  3603.       return;
  3604.  
  3605.     /*
  3606.      * With 3.91 we're using a new strategy for finding and operating
  3607.      * on all the messages with deleted status.  The idea is to do a
  3608.      * mail_search for deleted messages so the elt's "searched" bit gets
  3609.      * set, and then to scan the elt's for them and set our local bit
  3610.      * to indicate they're excluded...
  3611.      */
  3612.     (void)count_flagged(stream, "DELETED");
  3613.  
  3614.     for(i = 1L; i <= msgs->max_msgno; ){
  3615.     if(mail_elt(stream, mn_m2raw(msgs, i))->searched){
  3616.         /*--- clear all flags to keep our counts consistent  ---*/
  3617.         set_lflag(stream, msgs, i, (MN_HIDE|MN_SLCT), 0);
  3618.         set_lflag(stream, msgs, i, MN_EXLD, 1); /* mark excluded */
  3619.  
  3620.         /* --- erase knowledge in sort array (shift array down) --- */
  3621.         for(j = i + 1; j <= msgs->max_msgno; j++)
  3622.           msgs->sort[j-1] = msgs->sort[j];
  3623. /* BUG: should compress strings of deleted message numbers */
  3624.  
  3625.         msgs->max_msgno = max(0L, msgs->max_msgno - 1L);
  3626.         msgno_flush_selected(msgs, i);
  3627.     }
  3628.     else
  3629.       i++;
  3630.     }
  3631.  
  3632.     /*
  3633.      * If we excluded away a zoomed display, unhide everything...
  3634.      */
  3635.     if(msgs->max_msgno > 0L && any_lflagged(msgs, MN_HIDE) >= msgs->max_msgno)
  3636.       for(i = 1L; i <= msgs->max_msgno; i++)
  3637.     set_lflag(stream, msgs, i, MN_HIDE, 0);
  3638. }
  3639.  
  3640.  
  3641.  
  3642. /*----------------------------------------------------------------------
  3643.   Got thru the message mapping table, and remove messages with given flag
  3644.  
  3645.    Accepts: stream -- mail stream to removed message references from
  3646.         msgs -- pointer to message manipulation struct
  3647.         f -- flags to use a purge criteria
  3648.   ----*/
  3649. void
  3650. msgno_include(stream, msgs)
  3651.      MAILSTREAM *stream;
  3652.      MSGNO_S     *msgs;
  3653. {
  3654.     long   i, slop, old_total, old_size;
  3655.     size_t len;
  3656.  
  3657.     for(i = 1L; i <= stream->nmsgs; i++)
  3658.       if(get_lflag(stream, NULL, i, MN_EXLD)){
  3659.       old_total        = msgs->max_msgno;
  3660.       old_size         = msgs->sort_size;
  3661.       slop             = (msgs->max_msgno + 1L) % 64;
  3662.       msgs->sort_size  = (msgs->max_msgno + 1L) + (64 - slop);
  3663.       len           = (size_t) msgs->sort_size * sizeof(long);
  3664.       if(msgs->sort){
  3665.           if(old_size != msgs->sort_size)
  3666.         fs_resize((void **)&(msgs->sort), len);
  3667.       }
  3668.       else
  3669.         msgs->sort = (long *)fs_get(len);
  3670.  
  3671.       msgs->sort[++msgs->max_msgno] = i;
  3672.       set_lflag(stream, msgs, msgs->max_msgno, MN_EXLD, 0);
  3673.  
  3674.       if(old_total <= 0L){            /* if no previous messages, */
  3675.           if(!msgs->select){        /* select the new message   */
  3676.           msgs->sel_size = 8L;
  3677.           len         = (size_t)msgs->sel_size * sizeof(long);
  3678.           msgs->select   = (long *)fs_get(len);
  3679.           }
  3680.  
  3681.           msgs->sel_cnt   = 1L;
  3682.           msgs->sel_cur   = 0L;
  3683.           msgs->select[0] = 1L;
  3684.       }
  3685.       }
  3686. }
  3687.  
  3688.  
  3689.  
  3690. /*----------------------------------------------------------------------
  3691.  Add the given number of raw message numbers to the end of the
  3692.  current list...
  3693.  
  3694.    Accepts: msgs - pointer to message manipulation struct
  3695.         n - number to add
  3696.    Returns: with fixed up msgno struct
  3697.  
  3698.    Only have to adjust the sort array, as since new mail can't cause
  3699.    selection!
  3700.   ----*/
  3701. void
  3702. msgno_add_raw(msgs, n)
  3703.      MSGNO_S *msgs;
  3704.      long     n;
  3705. {
  3706.     long   slop, old_total, old_size;
  3707.     size_t len;
  3708.  
  3709.     if(!msgs || n <= 0L)
  3710.       return;
  3711.  
  3712.     old_total        = msgs->max_msgno;
  3713.     old_size         = msgs->sort_size;
  3714.     msgs->max_msgno += n;
  3715.     slop             = (msgs->max_msgno + 1L) % 64;
  3716.     msgs->sort_size  = (msgs->max_msgno + 1L) + (64 - slop);
  3717.     len             = (size_t) msgs->sort_size * sizeof(long);
  3718.     if(msgs->sort){
  3719.     if(old_size != msgs->sort_size)
  3720.       fs_resize((void **)&(msgs->sort), len);
  3721.     }
  3722.     else
  3723.       msgs->sort = (long *)fs_get(len);
  3724.  
  3725.     for(slop = old_total + 1L; slop <= msgs->max_msgno; slop++)
  3726.       msgs->sort[slop] = slop;
  3727.  
  3728.     if(old_total <= 0L){            /* if no previous messages, */
  3729.     if(!msgs->select){            /* select the new message   */
  3730.         msgs->sel_size = 8L;
  3731.         len           = (size_t)msgs->sel_size * sizeof(long);
  3732.         msgs->select   = (long *)fs_get(len);
  3733.     }
  3734.  
  3735.     msgs->sel_cnt   = 1L;
  3736.     msgs->sel_cur   = 0L;
  3737.     msgs->select[0] = 1L;
  3738.     }
  3739. }
  3740.  
  3741.  
  3742.  
  3743. /*----------------------------------------------------------------------
  3744.   Remove all knowledge of the given raw message number
  3745.  
  3746.    Accepts: msgs - pointer to message manipulation struct
  3747.         n - number to remove
  3748.    Returns: with fixed up msgno struct
  3749.  
  3750.    After removing *all* references, adjust the sort array and
  3751.    various pointers accordingly...
  3752.   ----*/
  3753. void
  3754. msgno_flush_raw(msgs, n)
  3755.      MSGNO_S *msgs;
  3756.      long     n;
  3757. {
  3758.     long i, old_sorted = 0L;
  3759.     int  shift = 0;
  3760.  
  3761.     if(!msgs)
  3762.       return;
  3763.  
  3764.     /*---- blast n from sort array ----*/
  3765.     for(i = 1L; i <= msgs->max_msgno; i++){
  3766.     if(msgs->sort[i] == n){
  3767.         old_sorted = i;
  3768.         shift++;
  3769.     }
  3770.  
  3771.     if(shift)
  3772.       msgs->sort[i] = msgs->sort[i + 1L];
  3773.  
  3774.     if(msgs->sort[i] > n)
  3775.       msgs->sort[i] -= 1L;
  3776.     }
  3777.  
  3778.     /*---- now, fixup select array ----*/
  3779.     msgs->max_msgno = max(0L, msgs->max_msgno - 1L);
  3780.     msgno_flush_selected(msgs, old_sorted);
  3781. }
  3782.  
  3783.  
  3784.  
  3785. /*----------------------------------------------------------------------
  3786.   Remove all knowledge of the given selected message number
  3787.  
  3788.    Accepts: msgs - pointer to message manipulation struct
  3789.         n - number to remove
  3790.    Returns: with fixed up selec members in msgno struct
  3791.  
  3792.    Remove reference and fix up selected message numbers beyond
  3793.    the specified number
  3794.   ----*/
  3795. void
  3796. msgno_flush_selected(msgs, n)
  3797.      MSGNO_S *msgs;
  3798.      long     n;
  3799. {
  3800.     long i;
  3801.     int  shift = 0;
  3802.  
  3803.     for(i = 0L; i < msgs->sel_cnt; i++){
  3804.     if(!shift && (msgs->select[i] == n))
  3805.       shift++;
  3806.  
  3807.     if(shift && i + 1L < msgs->sel_cnt)
  3808.       msgs->select[i] = msgs->select[i + 1L];
  3809.  
  3810.     if(n < msgs->select[i] || msgs->select[i] > msgs->max_msgno)
  3811.       msgs->select[i] -= 1L;
  3812.     }
  3813.  
  3814.     if(shift && msgs->sel_cnt > 1L)
  3815.       msgs->sel_cnt -= 1L;
  3816. }
  3817.  
  3818.  
  3819.  
  3820. /*----------------------------------------------------------------------
  3821.   Test to see if the given message number is in the selected message
  3822.   list...
  3823.  
  3824.    Accepts: msgs - pointer to message manipulation struct
  3825.         n - number to test
  3826.    Returns: true if n is in selected array, false otherwise
  3827.  
  3828.   ----*/
  3829. int
  3830. msgno_in_select(msgs, n)
  3831.      MSGNO_S *msgs;
  3832.      long     n;
  3833. {
  3834.     long i;
  3835.  
  3836.     if(msgs)
  3837.       for(i = 0L; i < msgs->sel_cnt; i++)
  3838.     if(msgs->select[i] == n)
  3839.       return(1);
  3840.  
  3841.     return(0);
  3842. }
  3843.  
  3844.  
  3845.  
  3846. /*----------------------------------------------------------------------
  3847.   return our index number for the given raw message number
  3848.  
  3849.    Accepts: msgs - pointer to message manipulation struct
  3850.         n - number to locate
  3851.    Returns: our index number of given raw message
  3852.  
  3853.   ----*/
  3854. long
  3855. msgno_in_sort(msgs, n)
  3856.      MSGNO_S *msgs;
  3857.      long     n;
  3858. {
  3859.     static long start = 1L;
  3860.     long        i;
  3861.  
  3862.     if(mn_get_total(msgs) < 1L)
  3863.       return(-1L);
  3864.     else if(mn_get_sort(msgs) == SortArrival && !any_lflagged(msgs, MN_EXLD))
  3865.       return((mn_get_revsort(msgs)) ? 1 + mn_get_total(msgs) - n  : n);
  3866.  
  3867.     if(start > mn_get_total(msgs))        /* reset start? */
  3868.       start = 1L;
  3869.  
  3870.     i = start;
  3871.     do {
  3872.     if(mn_m2raw(msgs, i) == n)
  3873.       return(start = i);
  3874.  
  3875.     if(++i > mn_get_total(msgs))
  3876.       i = 1L;
  3877.     }
  3878.     while(i != start);
  3879.  
  3880.     return(0L);
  3881. }
  3882.  
  3883.  
  3884.  
  3885. /*
  3886.  *           * * *  Index entry cache manager  * * *
  3887.  */
  3888.  
  3889. /*
  3890.  * at some point, this could be made part of the pine_state struct.
  3891.  * the only changes here would be to pass the ps pointer around
  3892.  */
  3893. static struct index_cache {
  3894.    void      *cache;                /* pointer to cache         */
  3895.    char      *name;                /* pointer to cache name    */
  3896.    long    num;                    /* # of last index in cache */
  3897.    size_t  size;                /* size of each index line  */
  3898.    int     need_format_setup;
  3899. } icache = { (void *) NULL, (char *) NULL, (long) 0, (size_t) 0, (int) 0 };
  3900.   
  3901. /*
  3902.  * cache size growth increment
  3903.  */
  3904.  
  3905. #ifdef    DOS
  3906. /*
  3907.  * the idea is to have the cache increment be a multiple of the block
  3908.  * size (4K), for efficient swapping of blocks.  we can pretty much
  3909.  * assume 81 character lines.
  3910.  *
  3911.  * REMEMBER: number of lines in the incore cache has to be a multiple 
  3912.  *           of the cache growth increment!
  3913.  */
  3914. #define    IC_SIZE        (50L)            /* cache growth increment  */
  3915. #define    ICC_SIZE    (50L)            /* enties in incore cache  */
  3916. #define FUDGE           (46L)            /* extra chars to make 4096*/
  3917.  
  3918. static char    *incore_cache = NULL;        /* pointer to incore cache */
  3919. static long      cache_block_s = 0L;        /* save recomputing time   */
  3920. static long      cache_base = 0L;        /* index of line 0 in block*/
  3921. #else
  3922. #define    IC_SIZE        100
  3923. #endif
  3924.  
  3925. /*
  3926.  * important values for cache building
  3927.  */
  3928. static MAILSTREAM *bc_this_stream = NULL;
  3929. static long  bc_start, bc_current;
  3930. static short bc_done = 0;
  3931.  
  3932.  
  3933. /*
  3934.  * way to return the current cache entry size
  3935.  */
  3936. int
  3937. i_cache_width()
  3938. {
  3939.     return(icache.size - sizeof(HLINE_S));
  3940. }
  3941.  
  3942.  
  3943. /* 
  3944.  * i_cache_size - make sure the cache is big enough to contain
  3945.  * requested entry
  3946.  */
  3947. int
  3948. i_cache_size(indx)
  3949.     long         indx;
  3950. {
  3951.     long j;
  3952.     size_t  newsize = sizeof(HLINE_S)
  3953.              + (max(ps_global->ttyo->screen_cols, 80) * sizeof(char));
  3954.  
  3955.     if(j = (newsize % sizeof(long)))        /* alignment hack */
  3956.       newsize += (sizeof(long) - (size_t)j);
  3957.  
  3958.     if(icache.size != newsize){
  3959.     clear_index_cache();            /* clear cache, start over! */
  3960.     icache.size = newsize;
  3961.     }
  3962.  
  3963.     if(indx > (j = icache.num - 1L)){        /* make room for entry! */
  3964.     size_t  tmplen = icache.size;
  3965.     char   *tmpline;
  3966.  
  3967.     while(indx >= icache.num)
  3968.       icache.num += IC_SIZE;
  3969.  
  3970. #ifdef    DOS
  3971.     tmpline = fs_get(tmplen);
  3972.     memset(tmpline, 0, tmplen);
  3973.     if(icache.cache == NULL){
  3974.         if(!icache.name)
  3975.           icache.name = temp_nam(NULL, "pi");
  3976.  
  3977.         if((icache.cache = (void *)fopen(icache.name,"w+b")) == NULL){
  3978.         sprintf(tmp_20k_buf, "Can't open index cache: %s",icache.name);
  3979.         fatal(tmp_20k_buf);
  3980.         }
  3981.  
  3982.         for(j = 0; j < icache.num; j++){
  3983.             if(fwrite(tmpline,tmplen,(size_t)1,(FILE *)icache.cache) != 1)
  3984.           fatal("Can't write index cache in resize");
  3985.  
  3986.         if(j%ICC_SIZE == 0){
  3987.           if(fwrite(tmpline,(size_t)FUDGE,
  3988.                 (size_t)1,(FILE *)icache.cache) != 1)
  3989.             fatal("Can't write FUDGE factor in resize");
  3990.             }
  3991.         }
  3992.     }
  3993.     else{
  3994.         /* init new entries */
  3995.         fseek((FILE *)icache.cache, 0L, 2);        /* seek to end */
  3996.  
  3997.         for(;j < icache.num; j++){
  3998.             if(fwrite(tmpline,tmplen,(size_t)1,(FILE *)icache.cache) != 1)
  3999.           fatal("Can't write index cache in resize");
  4000.  
  4001.         if(j%ICC_SIZE == 0){
  4002.           if(fwrite(tmpline,(size_t)FUDGE,
  4003.                 (size_t)1,(FILE *)icache.cache) != 1)
  4004.             fatal("Can't write FUDGE factor in resize");
  4005.             }
  4006.         }
  4007.     }
  4008.  
  4009.     fs_give((void **)&tmpline);
  4010. #else
  4011.     if(icache.cache == NULL){
  4012.         icache.cache = (void *)fs_get((icache.num+1)*tmplen);
  4013.         memset(icache.cache, 0, (icache.num+1)*tmplen);
  4014.     }
  4015.     else{
  4016.             fs_resize((void **)&(icache.cache), (size_t)(icache.num+1)*tmplen);
  4017.         tmpline = (char *)icache.cache + ((j+1) * tmplen);
  4018.         memset(tmpline, 0, (icache.num - j) * tmplen);
  4019.     }
  4020. #endif
  4021.     }
  4022.  
  4023.     return(1);
  4024. }
  4025.  
  4026. #ifdef    DOS
  4027. /*
  4028.  * read a block into the incore cache
  4029.  */
  4030. void
  4031. icread()
  4032. {
  4033.     size_t n;
  4034.  
  4035.     if(fseek((FILE *)icache.cache, (cache_base/ICC_SIZE) * cache_block_s, 0))
  4036.       fatal("ran off end of index cache file in icread");
  4037.  
  4038.     n = fread((void *)incore_cache, (size_t)cache_block_s, 
  4039.         (size_t)1, (FILE *)icache.cache);
  4040.  
  4041.     if(n != 1L)
  4042.       fatal("Can't read index cache block in from disk");
  4043. }
  4044.  
  4045.  
  4046. /*
  4047.  * write the incore cache out to disk
  4048.  */
  4049. void
  4050. icwrite()
  4051. {
  4052.     size_t n;
  4053.  
  4054.     if(fseek((FILE *)icache.cache, (cache_base/ICC_SIZE) * cache_block_s, 0))
  4055.       fatal("ran off end of index cache file in icwrite");
  4056.  
  4057.     n = fwrite((void *)incore_cache, (size_t)cache_block_s,
  4058.         (size_t)1, (FILE *)icache.cache);
  4059.  
  4060.     if(n != 1L)
  4061.       fatal("Can't write index cache block in from disk");
  4062. }
  4063.  
  4064.  
  4065. /*
  4066.  * make sure the necessary block of index lines is in core
  4067.  */
  4068. void
  4069. i_cache_hit(indx)
  4070.     long         indx;
  4071. {
  4072.     dprint(9, (debugfile, "i_cache_hit: %ld\n", indx));
  4073.     /* no incore cache, create it */
  4074.     if(!incore_cache){
  4075.     cache_block_s = (((long)icache.size * ICC_SIZE) + FUDGE)*sizeof(char);
  4076.     incore_cache  = (char *)fs_get((size_t)cache_block_s);
  4077.     cache_base = (indx/ICC_SIZE) * ICC_SIZE;
  4078.     icread();
  4079.     return;
  4080.     }
  4081.  
  4082.     if(indx >= cache_base && indx < (cache_base + ICC_SIZE))
  4083.     return;
  4084.  
  4085.     icwrite();
  4086.  
  4087.     cache_base = (indx/ICC_SIZE) * ICC_SIZE;
  4088.     icread();
  4089. }
  4090. #endif
  4091.  
  4092.  
  4093. /*
  4094.  * return the index line associated with the given message number
  4095.  */
  4096. HLINE_S *
  4097. get_index_cache(msgno)
  4098.     long         msgno;
  4099. {
  4100.     if(!i_cache_size(--msgno)){
  4101.     q_status_message(SM_ORDER, 0, 3, "get_index_cache failed!");
  4102.     return(NULL);
  4103.     }
  4104.  
  4105. #ifdef    DOS
  4106.     i_cache_hit(msgno);            /* get entry into core */
  4107.     return((HLINE_S *)(incore_cache 
  4108.           + ((msgno%ICC_SIZE) * (long)max(icache.size,FUDGE))));
  4109. #else
  4110.     return((HLINE_S *) ((char *)(icache.cache) 
  4111.        + (msgno * (long)icache.size * sizeof(char))));
  4112. #endif
  4113. }
  4114.  
  4115.  
  4116. /*
  4117.  * the idea is to pre-build and cache index lines while waiting
  4118.  * for command input.
  4119.  */
  4120. void
  4121. build_header_cache()
  4122. {
  4123.     long lines_per_page = max(0,ps_global->ttyo->screen_rows - 5);
  4124.  
  4125.     if(mn_get_total(ps_global->msgmap) == 0 || ps_global->mail_stream == NULL
  4126.        || (bc_this_stream == ps_global->mail_stream && bc_done >= 2)
  4127.        || any_lflagged(ps_global->msgmap, (MN_HIDE|MN_EXLD|MN_SLCT)))
  4128.       return;
  4129.  
  4130.     if(bc_this_stream != ps_global->mail_stream){ /* reset? */
  4131.     bc_this_stream = ps_global->mail_stream;
  4132.     bc_current = bc_start = top_ent_calc(ps_global->mail_stream,
  4133.                          ps_global->msgmap,
  4134.                          mn_get_cur(ps_global->msgmap),
  4135.                          lines_per_page);
  4136.     bc_done  = 0;
  4137.     }
  4138.  
  4139.     if(!bc_done && bc_current > mn_get_total(ps_global->msgmap)){ /* wrap? */
  4140.     bc_current = bc_start - lines_per_page;
  4141.     bc_done++;
  4142.     }
  4143.     else if(bc_done == 1 && (bc_current % lines_per_page) == 1)
  4144.       bc_current -= (2L * lines_per_page);
  4145.  
  4146.     if(bc_current < 1)
  4147.       bc_done = 2;            /* really done! */
  4148.     else
  4149.       (void)build_header_line(ps_global, ps_global->mail_stream,
  4150.                   ps_global->msgmap, bc_current++);
  4151. }
  4152.  
  4153.  
  4154. /*
  4155.  * erase a particular entry in the cache
  4156.  */
  4157. void
  4158. clear_index_cache_ent(indx)
  4159.     long indx;
  4160. {
  4161.     HLINE_S *tmp = get_index_cache(indx);
  4162.  
  4163.     tmp->line[0] = '\0';
  4164.     tmp->id      = 0L;
  4165. }
  4166.  
  4167.  
  4168. /*
  4169.  * clear the index cache associated with the current mailbox
  4170.  */
  4171. void
  4172. clear_index_cache()
  4173. {
  4174. #ifdef    DOS
  4175.     cache_base = 0L;
  4176.     if(incore_cache)
  4177.       fs_give((void **)&incore_cache);
  4178.  
  4179.     if(icache.cache){
  4180.     fclose((FILE *)icache.cache);
  4181.     icache.cache = NULL;
  4182.     }
  4183.  
  4184.     if(icache.name){
  4185.     unlink(icache.name);
  4186.     fs_give((void **)&icache.name);
  4187.     }
  4188. #else
  4189.     if(icache.cache)
  4190.       fs_give((void **)&(icache.cache));
  4191. #endif
  4192.     icache.num  = 0L;
  4193.     icache.size = 0;
  4194.     bc_this_stream = NULL;
  4195.     set_need_format_setup();
  4196. }
  4197.  
  4198.  
  4199. void
  4200. set_need_format_setup()
  4201. {
  4202.     icache.need_format_setup = 1;
  4203. }
  4204.  
  4205.  
  4206. void
  4207. clear_need_format_setup()
  4208. {
  4209.     icache.need_format_setup = 0;
  4210. }
  4211.  
  4212.  
  4213. int
  4214. check_need_format_setup()
  4215. {
  4216.     return(icache.need_format_setup);
  4217. }
  4218.  
  4219.  
  4220. #ifdef    DOS
  4221. /*
  4222.  * flush the incore_cache, but not the whole enchilada
  4223.  */
  4224. void
  4225. flush_index_cache()
  4226. {
  4227.     if(incore_cache){
  4228.     if(mn_get_total(ps_global->msgmap) > 0L)
  4229.       icwrite();            /* write this block out to disk */
  4230.  
  4231.     fs_give((void **)&incore_cache);
  4232.     cache_base = 0L;
  4233.     }
  4234. }
  4235. #endif
  4236.  
  4237.  
  4238. #ifdef _WINDOWS
  4239. /*----------------------------------------------------------------------
  4240.   Callback to get the text of the current message.  Used to display
  4241.   a message in an alternate window.      
  4242.  
  4243.   Args: cmd - what type of scroll operation.
  4244.     text - filled with pointer to text.
  4245.     l - length of text.
  4246.     style - Returns style of text.  Can be:
  4247.         GETTEXT_TEXT - Is a pointer to text with CRLF deliminated
  4248.                 lines
  4249.         GETTEXT_LINES - Is a pointer to NULL terminated array of
  4250.                 char *.  Each entry points to a line of
  4251.                 text.
  4252.                     
  4253.         this implementation always returns GETTEXT_TEXT.
  4254.  
  4255.   Returns: TRUE - did the scroll operation.
  4256.        FALSE - was not able to do the scroll operation.
  4257.  ----*/
  4258. int
  4259. index_scroll_callback (cmd, scroll_pos)
  4260. int    cmd;
  4261. long    scroll_pos;
  4262. {
  4263.     int paint = TRUE;
  4264.     
  4265.     switch (cmd) {
  4266.       case MSWIN_KEY_SCROLLUPLINE:
  4267.     paint = index_scroll_up (1);
  4268.     break;
  4269.  
  4270.       case MSWIN_KEY_SCROLLDOWNLINE:
  4271.     paint = index_scroll_down (1);
  4272.     break;
  4273.  
  4274.       case MSWIN_KEY_SCROLLUPPAGE:
  4275.     paint = index_scroll_up (current_index_state->lines_per_page);
  4276.     break;
  4277.  
  4278.       case MSWIN_KEY_SCROLLDOWNPAGE:
  4279.     paint = index_scroll_down (current_index_state->lines_per_page);
  4280.     break;
  4281.  
  4282.       case MSWIN_KEY_SCROLLTO:
  4283.     paint = index_scroll_to_pos (scroll_pos + 1);
  4284.     break;
  4285.     }
  4286.  
  4287.     if(paint){
  4288.     mswin_beginupdate();
  4289.     update_titlebar_message();
  4290.     update_titlebar_status();
  4291.     redraw_index_body();
  4292.     mswin_endupdate();
  4293.     }
  4294.  
  4295.     return(paint);
  4296. }
  4297.  
  4298.  
  4299. /*----------------------------------------------------------------------
  4300.      MSWin scroll callback to get the text of the current message
  4301.  
  4302.   Args: title - title for new window
  4303.     text - 
  4304.     l - 
  4305.     style - 
  4306.  
  4307.   Returns: TRUE - got the requested text
  4308.        FALSE - was not able to get the requested text
  4309.  ----*/
  4310. int
  4311. index_gettext_callback(title, text, l, style)
  4312.     char  *title;
  4313.     void **text;
  4314.     long  *l;
  4315.     int   *style;
  4316. {
  4317.     ENVELOPE *env;
  4318.     BODY     *body;
  4319.     STORE_S  *so;
  4320.     gf_io_t   pc;
  4321.  
  4322.     if(mn_get_total(ps_global->msgmap) > 0L
  4323.        && (so = so_get(CharStar, NULL, WRITE_ACCESS))){
  4324.     gf_set_so_writec(&pc, so);
  4325.  
  4326.     if((env = mail_fetchstructure(ps_global->mail_stream,
  4327.                       mn_m2raw(ps_global->msgmap,
  4328.                            mn_get_cur(ps_global->msgmap)),
  4329.                       &body))
  4330.        && format_message(mn_m2raw(ps_global->msgmap,
  4331.                       mn_get_cur(ps_global->msgmap)),
  4332.                  env, body, FM_NEW_MESS, pc)){
  4333.         sprintf(title, "Folder %.50s  --  Message %ld of %ld",
  4334.             ps_global->cur_folder,
  4335.             mn_get_cur(ps_global->msgmap),
  4336.             mn_get_total(ps_global->msgmap));
  4337.         *text  = so_text(so);
  4338.         *l     = strlen((char *)so_text(so));
  4339.         *style = GETTEXT_TEXT;
  4340.  
  4341.         /* free alloc'd so, but preserve the text passed back to caller */
  4342.         so->txt = (void *)NULL;
  4343.         so_give(&so);
  4344.         return(1);
  4345.     }
  4346.     }
  4347.  
  4348.     return(0);
  4349. }
  4350. #endif    /* _WINDOWS */
  4351.